#define conditionnel à problème

Version imprimable

19/11/2009, 11h34
bpy1401

#define conditionnel à problème
Bonjour à tous.

je cherche à faire une macro conditionnelle et comme ce terme n'est pas clair un petit exemple va être plus compréhensible
Code:

1 2 3 4 5 6 7 #define MA_MACRO(name) \ #ifdef ALREADY_DEFINE_##name \ printf("%s est deja definie\n",name); \ #else \ printf("%s n'est pas defini\n",name); \ #endif
bien évidemment, mon préprocesseur n'apprécie pas le #ifdef dans un #define
Qui pourrais me donner une idée pour résoudre le problème

merci d'avance

bonjour,

moi je le ferais dans l'autre sens. Quelque chose du style:

Code:

1
2
3
4
5
#ifdef ALREADY_DEFINE
   #define MA_MACRO(name) printf("%s est deja definie\n",name);
#else
   #define MA_MACRO(name) printf("%s n'est pas defini\n",name);
#endif

19/11/2009, 12h41
bpy1401

Bonjour,

je ne peux pas dans ce sens car le #ifdef prend en compte un des paramètres de la macro (paramètre name).

Citation:

#define MA_MACRO(name) \
#ifdef ALREADY_DEFINE_##name \
19/11/2009, 16h55
Pouet_forever

Concrètement je ne crois pas que ce soit possible.
Parce que les directives de préprocesseur sont évaluées à la compilation et non à l'exécution. De ce fait faire un #ifdef avec une variable n'a pas de sens :?

Seule la déclaration de r0d est correcte, parce que #ifdef ALREADY_DEFINE peut être évaluée à la compilation ;)
19/11/2009, 17h35
Thierry Chappuis

A mon avis, ce n'est pas possible de faire ce que tu veux faire ici. La première question qui me vient à l'esprit est pourquoi veux-tu faire cela? Il y a peut-être (certainement) une meilleures solution.

Thierry
19/11/2009, 17h37
r0d

Effectivement, j'ai beau tourner le problème dans tous les sens, je ne vois pas de solution.
Ne pourrais-tu pas faire ce que tu veux en utilisant une structure instanciée en global?
19/11/2009, 17h40
jabbounet
Citation:

Envoyé par r0d

Effectivement, j'ai beau tourner le problème dans tous les sens, je ne vois pas de solution.
Ne pourrais-tu pas faire ce que tu veux en utilisant une structure instanciée en global?

Et pour le printf peu etre que (je suis un peu rouillé)
Code:

1 2 #define MA_MACRO(name) printf(#name" est deja definie\n");
Tu as aussi la possibilité de placer des warning/erreurs de compile
Code:

1 2 3 #warning "un message" #error "un message"

Bonjour à tous

merci pour vos réponse.

En fait, le fichier H est un fichier généré automatiquement par un outil à partir d'un fichier EXCEL. La macro doit faire appel à une fonction si NAME est défini dans le fichier EXCEL, car on doit dans ce cas faire appel à une fonction bien spécfique, sinon on doit sauvegarder une valeur dans une variable globale nommée NAME. L'exemple que j'ai donné est juste pour décrire ce que je souhaitais faire, il n'y aura pas de printf dans l'application.

Dans la version précédente du logiciel, des que l'on tombait sur un NAME inexistant, on devait rajouter manuellement la copie de la variable dans le fichier .h, et comme le nombre de cas se multiplie, cela devient très lourd à gérer, d'ou l'idée d'un macro qui s'adapte à l'existance ou nom d'un define.

Je ne peux pas vous donner la vrai code, mais voici un exemple plus parlant

le fichier H auto généré
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 /* ------------------------------ */ /* Partie générée automatiquement */ /* ------------------------------ */ #define VAR_UneVariable 1 #define VAR_UneAutreVariable 1 /* Fonction d'assignation de UneVariable */ #define VAR_SET_UneVariable(value) \ set_value_UneVariable(value) /* Fonction d'assignation de UneAutreVariable */ #define VAR_SET_UneVariable(value) \ send_value_UneAutreVariable(value) /* Macro générique pour l'assignataion des variables */ #define ASSIGN_SET(name,value) #ifdef VAR_##name VAR_SET_##name(value) #else name = value #endif
et un .C utilisant ce .h
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include "Assign.h" int LocalVariable; void set_value_UneVariable(int val) { } void send_value_UneAutreVariable(int val) { } void main(void) { ASSIGN_SET(UneVariable,1); ASSIGN_SET(UneAutreVariable,1); ASSIGN_SET(LocalVariable,1); }
J'espère que mon explication est plus clair

20/11/2009, 09h13
Pouet_forever
Comme je t'ai dis plus haut « les directives de préprocesseur sont évaluées à la compilation et non à l'exécution. ».
Donc ce que tu veux faire est incorrect. Il faut que tu trouves autre chose :)

C'est un peu comme si tu voulais faire ça :
Code:

1 2 3 4 5 6 if (1) { #define N 10 } else { #define N 20 }
Normalement ton compilateur doit te mettre un joli message d'erreur en te disant que N est déjà déclaré ;)
24/11/2009, 23h31
Médinoc

C'est bien au préprocesseur que briand patrick veut faire son test.

Malheureusement, il est à ma connaissance impossible d'inclure un #if dans un #define. J'ai moi-même été confronté à un problème de ce genre...

Citation:

Envoyé par briand patrick

bien évidemment, mon préprocesseur n'apprécie pas le #ifdef dans un #define

je pense que ce qu'il n'appréie pas, c'est les blancs (espaces) devant..

Il est tout à fait possible de faire :
Code:

1 2 3 4 5 6 7 8 9 #ifdef TOTO /* Cas ou TOTO est defini */ #ifdef TATA /* Cas ou TATA et TOTO sont defini */ fprintf ( stderr, "TITI"); #else /* cas ou TATA n'est pas defini mais TOTO l'est */ fprintf ( stderr, "TUTU"); #endif #else /* Cas ou TOTO n'est pas defini */ fprintf ( stderr, "TUTLUTUTU"); #endif
Mais le pré-processeur n'accepte les #if, #ifdef, #else, etc, que en PREMIERE colonne....

26/11/2009, 15h08
Médinoc

Citation:

Envoyé par souviron34

je pense que ce qu'il n'appréie pas, c'est les blancs (espaces) devant..
<snip>
Mais le pré-processeur n'accepte les #if, #ifdef, #else, etc, que en PREMIERE colonne....

C'est dans la norme, ça?

Je viens de tester, Visual et gcc acceptent aussi bien #if que (tab)#if, et même #(tab)if...
26/11/2009, 15h53
souviron34

Citation:

Envoyé par Médinoc

C'est dans la norme, ça?

aucune idée, mais je me souviens m'être fait jeter plusieurs fois....

Sinon, je suis également certain qu'il n'apprécie pas ceci :

Code:

#ifdef ALREADY_DEFINE_##name

Puisque on est en pré-compilation, name n'est pas défini et donc ce ifdef ne correspond pas à une constante...

Maintenant, je crois que je comprend ce que veux faire le PO, et c'est impossible : je pense qu'il veut pouvoir tester (au runtime) si tel ou tel symbole est défini en le construisant dynamiquement....
26/11/2009, 15h59
Médinoc
Non, il veut bien le faire en compile-time, mais c'est impossible aussi.

Un exemple simplifié, imagine qu'il veut obtenir ceci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 switch(toto) { #ifdef DEF_A case DEF_A: return "DEF_A"; #endif #ifdef DEF_B case DEF_B: return "DEF_B"; #endif #ifdef DEF_C case DEF_C: return "DEF_C"; #endif }
À partir de ceci:
Code:

1 2 3 4 5 6 switch(toto) { #define ITEM (quelque chose) #include "DEFs.itm" #undef ITEM }
Code:

1 2 3 4 /*DEFs.itm*/ ITEM(DEF_A) ITEM(DEF_B) ITEM(DEF_C)
C'est une chose que j'ai moi-même essayé de faire, avec toutes les valeurs des codes d'erreur de Windows: J'ai été obligé de mettre les #ifdef, à cause des différentes versions du SDK.
En gros, un #define dont l'expansion donne des #ifdef.

Réponse:
...Et bien je n'ai pas pu le faire, j'ai du passer mon .itm dans une moulinette pour en faire ceci:
Code:

1 2 3 4 5 6 7 8 9 10 /*DEFs2.itm*/ #ifdef DEF_A ITEM(DEF_A) #endif #ifdef DEF_B ITEM(DEF_B) #endif #ifdef DEF_C ITEM(DEF_C) #endif
27/11/2009, 10h19
souviron34

mais c'est absolument évident !!!

un #define définit une constante, stockée à un certain endroit par le compilo..mais il n'éxécute pas de code.. sauf les quelques instructions définies par les #...

Il n'y a pas besoin de se torturer la cervelle..

Il y a tout simplement une erreur de conception si on veut faire ce genre de choses...

Dans ton exemple des erreurs, il doit y avoir quelque part un GetError (comme le errno) qui te retourne un entier..

A toi de faire un switch ensuite,

J'avoue être dans l'incompréhension la plus totale par rapport à ce qu'on pourrait vouloir faire avec ceci...
27/11/2009, 10h47
Médinoc
Tu n'as pas compris, ça utilise déjà le résultat entier de GetErreur(), c'est déjà pour un switch, et c'est déjà statique.

C'est juste qu'on peut avoir envie d'utiliser une item-list au lieu de se taper tous les case manuellement. Et comme les trucs ne sont pas toujours définis...

Dans le code du posteur originel, c'est le même schéma:
- POUR chaque élément
  - SI macro_correspondant_a_cet_element est #défini
    
    utiliser la macro
  - SINON
    
    autre chose
Bien sûr, je sais que c'est impossible, mais ce n'est pas une raison pour dire qu'avoir envie de le faire est une erreur.

désolé je continue à ne pas comprendre....

Mais si je reprends l'exemple donné par le PO, je crois que ce qui pêche c'est (encore une fois :roll:) vouloir faire de l'objet avec du C.. (ce que visiblement fait la traduction automatique du .h)

Plus une (très) mauvaise utilisation de macros (qui a fait fureur dans certains milieux au début des années 90).. Définir des appels de fonctions par macro... J'ai eu à travailler sur un code comme ça et c'est une horreur absolue.... En particulier pour la lecture et le debug... (il faut se référer en permanence au .h pour savoir ce que fait cette macro particulière, et en debug pas à pas c'est un enfer : tu penses que c'est une fonction, donc tu fais "step in", et ça te jette... et quand en plus cela sert à appeler une fonction commune avec des paramètres particuliers, n'en parlons pas...).

Quand on lit :
Code:

1 2 3 4 5 6 7 8 /* Fonction d'assignation de UneVariable */ #define VAR_SET_UneVariable(value) \ set_value_UneVariable(value) /* Fonction d'assignation de UneAutreVariable */ #define VAR_SET_UneVariable(value) \ send_value_UneAutreVariable(value)
L'écriture de ces fonctions est une manière de penser Objet (une méthode par type d'objet), alors qu'une manière C serait :
Code:

1 2 /* Fonction d'assignation de une variable */ set_value_Variable(int IndicVariable, value);
où on n'a absolument pas besoin de faire toutes ces manipulations... C'est donc bien ce que je disais une erreur de conception fondamentale...

Maintenant, si on ne peut pas modifier le .h, alors il n'y a qu'une seule manière simple et lisible et efficace de faire ce qu'on veut, c'est :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void SetVariable ( int TypeVariable, void *Value) { switch ( TypeVariable ) { case VAR_UneVariable : VAR_SET_UneVariable(value) ; break ; case VAR_UneAutreVariable : VAR_SET_UneAutreVariable(value) ; break ; } }
Le reste est de la jonglerie intellectuelle qui ne fait que compliquer la lecture du code (qui à cause de cette manière est de toutes façons déjà trop compliqué).

Et quand tu dis "on peut avoir envie d'utiliser une item-list", mais tu fais exactement un switch-case.. Alors peut-être que pour toi , dans ton esprit, tu le vois autrement, mais quand je lis :
Code:

1 2 3 4 5 6 7 8 9 10 11 /*DEFs2.itm*/ #ifdef DEF_A ITEM(DEF_A) #endif #ifdef DEF_B ITEM(DEF_B) #endif #ifdef DEF_C ITEM(DEF_C) #endif
je ne vois rien d'autre qu'un switch fait par le préprocesseur... Et en terme de nombre de caractères entrés par toi, c'est le même... donc je ne vois pas le gain...

Et si on veut le faire dynamiquement, ça ne marche pas..

La seule manière dynamique est celle du vrai switch...

Alors où on ne ne fait pas de define, et on a un indicateur entier (un tableau), ou on a des define, et la solution normale est le switch..

Ton exemple est une fonction ITEM..

Eh bien cette fonction est simple : ITEM(int)..

Pourquoi vouloir la "surcharger" ????

Je saute la première partie de ton argumentaire, car je ne suis pas sûr d'avoir raison ou non sur la pertinence de ce modèle.
Citation:
Envoyé par souviron34
Et quand tu dis "on peut avoir envie d'utiliser une item-list", mais tu fais exactement un switch-case.. Alors peut-être que pour toi , dans ton esprit, tu le vois autrement, mais quand je lis :
Code:

1 2 3 4 5 6 7 8 9 10 11 /*DEFs2.itm*/ #ifdef DEF_A ITEM(DEF_A) #endif #ifdef DEF_B ITEM(DEF_B) #endif #ifdef DEF_C ITEM(DEF_C) #endif
je ne vois rien d'autre qu'un switch fait par le préprocesseur...
Pour le préprocesseur lui-même, ça n'est pas un switch, vu que toutes les valeurs peuvent être définies à la fois (dans mon cas pour les erreurs, c'est le cas si on a un SDK à jour). Mais ça sert à écrire le code C d'un switch.

Citation:

Et en terme de nombre de caractères entrés par toi, c'est le même... donc je ne vois pas le gain...

C'est le même parce ce qu'on cherche à faire est impossible. Mais ça permet aussi de faire autre chose qu'un simple switch dans le code. L'intéret d'une item-list, c'est qu'elle est réutilisable. Le problème de celle-ci, c'est qu'on n'est pas sûr que chaque élément existe.

Citation:

Et si on veut le faire dynamiquement, ça ne marche pas..

La seule manière dynamique est celle du vrai switch...

Alors où on ne ne fait pas de define, et on a un indicateur entier (un tableau), ou on a des define, et la solution normale est le switch..

Mais mon code utilise un vrai switch. C'est juste qu'on le peuple avec une item-list réutilisable, plutôt qu'écrire chaque case à la main.

Citation:

Ton exemple est une fonction ITEM..

Eh bien cette fonction est simple : ITEM(int)..

Pourquoi vouloir la "surcharger" ????

Dans le cas présent, ITEM est forcément une macro, vu que j'y emploie l'opérateur #.

En gros, ce que je voulais, c'est pouvoir faire ceci:
Code:

1 2 3 4 5 6 7 8 switch(errorCode) { case ERROR_FILE_NOT_FOUND: return "ERROR_FILE_NOT_FOUND"; case ERROR_ACCESS_DENIED: return "ERROR_ACCESS_DENIED"; #ifdef SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION case SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION: return "SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION"; #endif }
Sans avoir à me taper tout à la main, et accessoirement en pouvant réutiliser la liste des defines d'erreur (récupérée sur MSDN) autre part.

ce que je maintiens, c'est que d'une part tu tapes plus de code, pour quelque chose qui n'est pas plus utilisable...

Et si vraiment tu veux faire ce que tu dis et être réutilisable, alors pourquoi simplement ne pas faire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
int ErrorCodes[]={
                         ERROR_FILE_NOT_FOUND,
                         ERROR_ACCESS_DENIED
#ifdef SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION
                         ,
                         SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION
#endif
                         };
char *Messages[]={
                         "ERROR_FILE_NOT_FOUND",
                         "ERROR_ACCESS_DENIED"
#ifdef SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION
                         ,
                         "SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION"
#endif
                         }
 
 
int FindIndexOfCode ( int Code)
{
  int i =0;
 
   while ( ErrorCodes[i] != Code )
     i++ ;
 
   return i ; 
}
 
void PrintError( int code)
{
   int icode ;
 
   icode = FindIndexOfCode(code);
   fprintf (stderr, "%s\n", Messages[icode]);
}

ou, si tu le veux dynamique :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int CodeErrors[MAX_ERREURS_MON_PROG], NCodes=0 ;
char *Messages[MAX_ERREURS_MON_PROG] ;
 
void RegisterCode ( int Code, char *Message )
{
    CodeErrors[NCodes] = Code ;
    Messages[NCodes] = strdup ( Message);
}
 
int FindIndexOfCode ( int Code)
{
  int i =0;
 
   while ( CodeErrors[i] != Code )
     i++ ;
 
   return i ; 
}
 
void PrintError( int code)
{
   int icode ;
 
   icode = FindIndexOfCode(code);
   fprintf (stderr, "%s\n", Messages[icode]);
}

et dans ton main ou ailleurs :

Code:

1
2
3
4
5
6
7
8
9
10
int main ( void )
{
....
 RegisterCode (ERROR_FILE_NOT_FOUND, "ERROR_FILE_NOT_FOUND");
 RegisterCode ( ERROR_ACCESS_DENIED, "ERROR_ACCESS_DENIED");
#ifdef SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION
  RegisterCode (SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION,
                    "SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION");
#endif
}

Je me moque du dynamique.

Le problème, c'est que ton truc est encore plus long à faire que les item-lists, surtout si je génère l'item-list pleine de #ifdef à partir de la première.

En fait, j'ai fini par me faire directement un programme qui partait de ceci:
Code:

1 2 3 ERROR_FILE_NOT_FOUND ERROR_ACCESS_DENIED SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION
Pour me générer ça.
Code:

1 2 3 4 5 6 7 8 9 #ifdef ERROR_FILE_NOT_FOUND ITEM(ERROR_FILE_NOT_FOUND) #endif #ifdef ERROR_ACCESS_DENIED ITEM(ERROR_ACCESS_DENIED) #endif #ifdef SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION ITEM(SOME_ERROR_DEFINED_IN_THE_LAST_SDK_VERSION) #endif

27/11/2009, 13h09
souviron34

Citation:

Envoyé par Médinoc

En fait, j'ai fini par me faire directement un programme

;)

et tu as passé vraisemblablement beaucoup plus de temps qu'à faire soit le switch simple , soit ce que j'ai fais en dynamique... :P

M'enfin, si tu as du temps.. 8-)

PS: je crois néanmoins que c'est une manière de faire qui rendra vite le code non maintenable... (voir mes remarques 2 posts au dessus).

PPS: 20 lignes de code pour avoir tout en souple, ça ne m'apparaît pas comme un travail insurmontable, non ? ;) je me demande si ton prog faisait moins de 20 lignes...

PPSS : l'avantage du dynamique (et de la structure associée) c'est que tu peux ajouter ce que tu veux : des fonctions spéciales, bref, toute une structure ("instance" d'une "classe") spécifique à ce code en particulier..
27/11/2009, 14h05
Médinoc
Citation:

Envoyé par souviron34

et tu as passé vraisemblablement beaucoup plus de temps qu'à faire soit le switch simple , soit ce que j'ai fais en dynamique...

J'en suis moins sûr que toi. Sais-tu combien de codes d'erreur Windows comporte?

De plus, l'avantage de l'item-list, c'est que je peux passer en dynamique quand je veux:
Code:

1 2 3 4 5 6 7 int main ( void ) { .... #define ITEM(x) RegisterCode(x, #x); #include "ErrorCodes.itm" #undef ITEM }