Un topic pour un noob en C - Page 4

Oé c'est l'idée ^^
Faudrait que ca me genere un truc du genre : "v0.1.0.1 tralali tralala"
Mais j'ai l'impression de m'etre planté dans mes "stringifications", je vais verifier tout ca

Ah! Mais avant; histoire que je comprenne bien ce que je fais :
#define STR1 "toto"
#define STR2 " tati"
#define str(x,y) xstr(x,y)
#define xstr(x,y) x ## y
#define STR_GEN str( STR1, STR2)

STR_GEN vaudra :
- "toto tati" (je pencherai pour ce resultat)
- ou ""toto"" tati"" ?

Edit > Tout compte fait non : ca genererai plutot (a mon avis) ""toto"" tati"" j'ai l'impression...

#define MAKEVERSION "v" str(VERSION) " "
?
(A mon avis, ça doit être plus compliqué que ça ^^)

C'est une idée Je vais tester

Non mais toute façon ce que tu veux faire ne marchera jamais.
STR_GEN vaudra une macro portant le nom de "toto""tati" Bref c'est impossible !!!
Ton str(x,y) devient donc #x#y

Ainsi :

#define VER 1.2.3.4
#define VER_SUFFIXE blabla
#define str_version(x, y) xstr_version(x, y)
#define xstr_version(x, y) "v"#x" "#y

int main(int argc, char *argv[])
{
puts(str_version(VER, VER_SUFFIXE));
system("PAUSE");
return 0;
}

C'est exactement ce que je cherchais! Merci Lionel

Donc en fait un #define se comporte presque comme un dc.b "une chaine","une autre chaine",0
J'était loin de penser ca!

./94 > cross
Vi c'est exactement ce que je viens de voir Ca explique pourquoi j'arrivais jamais a generer ce que je voulais
J'avais pas compris que tant que le preprocesseur ne recontrait pas la fin ligne il continuais a "coller" les éléments
Merci bien

Encore un probleme avec le preprocesseur :
N'y a-t-il vraiment aucun moyen de lui faire calculer quoique ce soit a partir de constantes ?
Est-ce inevitablement la tache du compilateur ?
Car pour generer mes numeros de versions etc...Ca me complique pas mal la tache

Edit > Tout ce qu'il sait me faire c'est ca :

#define TRUC 5
#define BIDULE 3

#define MAC_Add(x,y) MAC_xAdd(x,y)
#define MAC_xAdd(x,y) ((x)+(y))

#define CHOSE MAC_Add(TRUC,BIDULE) // et ca me donne : ((5)+(3))

Euh un préprocesseur ne fait aucun calcul !!!

Rahhh!!!! Cay nuuulll
Bon ben je vais faire avec ^^'

Ba si ce sont des constantes c'est le compilo qui le fera le calcul au moment de la compilation... ça change pas gd chose

aka si tu fait


a = 1 + 2;

le compilo va pas faire

move #1, r0
add #2, r0
move r0, a

mais

move #3, a

Je ne connais aucun compilo qui ne fasse pas ça (et meme si je me trompe pas c'est meme le cas sans optim, et bien sur QUE pour les constantes)

Oui sauf si j'ai besoin de generer une chaine en fonction d'un calcul sur ces constantes
Car afficher : "((1)+(2))" au lieu de "3"...
(Mais là je ne prend exemple que pour la StatusLine a qui je passe une chaine directement; pour un printf ca marche sans probleme par contre )
Elle était bien pratique cette statusline Mais je crois que je vais devoir m'en passer

T'as pas tord Martial
Ca m'donne une idée...

C'est qui l'tordu ?! Moi ?!

En tous cas j'ai ecouté ton conseil et j'ai changé de structure
Ca marche au poil

J'était completment a coté de la plaque desolé Martial

Je reviens a la charge

J'ai remarqué quelque chose d'assez etonnant avec le preprocesseur :
Lorsque l'on fait un test avec des #if de ce genre :

#define UN 1
#define DEUX 2

#if ((UN + DEUX) == 3)
// ...
#endif

Le preprocesseur est capable d'evaluer (UN + DEUX).
Alors je sais que c'est pas dans la norme standard C, mais je me demande pourquoi :
#define TROIS (UN + DEUX)
n'est pas evalué dans ce cas (tâche qui est dechargée au compilateur a cause de la norme).
C'est etonnant que la norme n'ai pas pris ca en charge, puisqu'on a vu que le preprocesseur était capable d'évaluer une expression de lui-meme
Meme les modulos sont évalués; alors pourquoi des opérations si basiques ne sont pas reconnues par le preprocesseur ?
J'hesite entre un oubli lors de la redaction de la norme ou alors il y a une raison particuliere mais je ne vois pas laquelle...

Edit > Et...ca m'embete bien cette histoire

Edit2 > En fin d'compte, la raison est peut-etre toute bete :
#define UN 1
#define DEUX C // hum! (sachant que le preprocesseur ne fait aucune verification de validité...)
#define TROIS (UN + DEUX)

c'est pasque le #define, il n'a pas besoin de le traduire la tout de suite il peut laisser le compilo le faire (et c'es du temps de gagné)

alors que pour le #if il en a besoin tout de suite pour savoir si il vaut evaluer ce qui est dans le #if #endif ou non

Ouais
En tous cas c'est une belle lacune quand meme, mais expliquée en partie par le fait qu'il n'y ait aucune verification
Dommage

Le rôle du préprocesseur est seulement de faire de la substitution de texte.
Dans le cas particulier #if, il est évidemment obligé d'évaluer la condition que tu lui donnes.