Est-il possible de sortinger les tableaux à l’aide du préprocesseur?

J’ai un certain nombre de très longs tableaux. Aucun sorting au moment de l’exécution n’est possible. Il est également fastidieux de les sortinger manuellement. De plus, de nouveaux éléments peuvent être ajoutés ultérieurement dans n’importe quel ordre. Je souhaite donc les sortinger par valeur à l’aide du préprocesseur C ou peut-être existe-t-il un indicateur de compilation (GCC)?

Par exemple:

sometype S[] = { {somevals, "BOB", someothervals}, {somevals, "ALICE", someothervals}, {somevals, "TIM", someothervals}, } 

doit être sortingé donc:

 sometype S[] = { {somevals, "ALICE", someothervals}, {somevals, "BOB", someothervals}, {somevals, "TIM", someothervals}, } 

Résolu

Ok, voici ma solution:

  1. Copiez et collez manuellement chaque tableau dans un fichier temporaire appelé tobesorted.c
  2. Triez-le par 2ème colonne: sort -b -i --key=2 tobesorted.c
  3. Copier-coller la sortie dans le fichier d’origine.

En fait, ce serait bien d’avoir la possibilité d’appeler “sort” directement à partir du pré-processeur (j’espérais au moins que GCC prenne en charge de telles fonctionnalités, mais il semble que ce n’est pas le cas).

Non ce n’est pas possible. Vous ne pouvez pas effectuer d’opérations sur les chaînes (autres que la concaténation) avec le préprocesseur. Et vous ne pouvez pas non plus comparer les chaînes avec la métaprogrammation de modèles.

[edit] Ce que vous pouvez faire est de placer votre structure de données dans un fichier destiné à être prétraité par un script de construction externe (par exemple, l’utilitaire de sorting Unix), puis de modifier votre makefile / projet de manière à générer au moment de la construction un fichier C avec les tableaux initialisés (sortingés)

Fais ça.

  1. Mettez votre tableau géant dans un fichier.

  2. Trier le fichier avec le sort intégré

  3. Ecrivez un petit programme pour créer du code C à partir du fichier. Programme AC qui écrit des programmes C est très bien. Vous pouvez utiliser Python et certains de ses packages de modèles pour simplifier ce travail.

  4. Comstackz le programme restant composé du fichier sortingé transformé en code C et du rest de votre programme.

Je ne pense pas que vous puissiez le faire dans le pré-processeur gcc, vous n’avez jamais rien vu qui puisse faire ce que vous cherchez.

Mais vous pourriez écrire votre propre “préprocesseur” dans votre langage de script préféré (python, perl, sed, etc.) qui sortingerait ces valeurs avant que gcc ne débute.

Je ne vois aucune possibilité d’utiliser le préprocesseur, mais vous pouvez utiliser une combinaison de sort et #include pour obtenir l’effet souhaité:

Placez uniquement les valeurs dans un fichier distinct values.h avec la clé de sorting devant (vous devrez réorganiser votre type de struct sometype pour cela):

 {"BOB", somevals, someothervals}, {"ALICE", somevals, someothervals}, {"TIM", somevals, someothervals}, 

Dans votre Makefile, utilisez la commande Unix sort pour sortinger ce fichier dans values_sorted.h :

 sort < values.h > values_sorted.h 

Dans votre code actuel, incluez le fichier sortingé:

 sometype S[] = { #include "values_sorted.h" }; 

Les éléments suivants ont fonctionné pour deux et trois éléments:

 // Experiment: static sort: #define STATIC_SORT2(CMP, a, b) CMP(a,b) <= 0 ?(a):(b), CMP(a,b) <= 0 ? (b):(a), #define STATIC_SORT3(CMP, a, b, c) \ (CMP(a,b) <= 0 && CMP(a,c) <= 0 ? (a) : \ CMP(b,a) <= 0 && CMP(b,c) <= 0 ? (b) : \ (c)), \ (CMP(a,b) <= 0 && CMP(a,c) <= 0 ? ( CMP(b,c) <= 0 ? (b) : (c) ) : \ CMP(b,a) <= 0 && CMP(b,c) <= 0 ? ( CMP(a,c) <= 0 ? (a) : (c) ) : \ (CMP(a,b) <= 0 ? (a) : (b))), \ (CMP(a,c) <= 0 && CMP(b,c) <= 0 ? (c) : \ CMP(a,b) <= 0 && CMP(c,b) <= 0 ? (b) : \ (a)) // Example: // #define STATIC_INT_CMP(a,b) ((int)(a) - (int)(b)) // int sorted[] = { STATIC_SORT3(STATIC_INT_CMP, 2, 3, 1 } // gives { 1, 2, 3 } // #define STATIC_INT_COCMP(a,b) ((int)(b) - (int)(a)) // int cosorted[] = { STATIC_SORT3(STATIC_INT_COCMP, 2, 3, 1 } // gives { 3, 2, 1 } 

Mais je dirais qu'il est clair que cette approche ne se généralise pas à des tableaux de taille arbitraire. Je suppose que ce n’est pas possible, mais je n’ai toujours pas de preuve formelle de cette conjecture.