bonjour
j'aurais voulu comprendre l'utilisation du ##, un exmple:
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
bonjour
j'aurais voulu comprendre l'utilisation du ##, un exmple:
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
bonjour
j'aurais voulu comprendre l'utilisation du ##, un exmple:
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
writes:bonjour
j'aurais voulu comprendre l'utilisation du ##, un exmple:
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
Mauvais exemple, je vois mal dans quel cas l'utiliser.
## fusionne les deux symboles qui l'entoure en un seul. Le cas le plus
courant est pour construire des identificateurs sur base d'une racine
passee en parametre.
Exemple simple
#define PUSH(type, value) push_##type(value)
PUSH(int, 5);
equivaut a
push_int(5);
Sans le ##, ce serait equivalent a
push_ int(5);
qui poserait probleme.
(La raison pour laquelle j'ai des doutes sur la pertinence de ton exemple
est que je ne vois pas de symbole commencant par . qu'on ait envie de
construire comme cela d'une part et qui soit utilisable dans ce contexte
d'autre part).
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
gpgnews@gmail.com writes:
bonjour
j'aurais voulu comprendre l'utilisation du ##, un exmple:
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
Mauvais exemple, je vois mal dans quel cas l'utiliser.
## fusionne les deux symboles qui l'entoure en un seul. Le cas le plus
courant est pour construire des identificateurs sur base d'une racine
passee en parametre.
Exemple simple
#define PUSH(type, value) push_##type(value)
PUSH(int, 5);
equivaut a
push_int(5);
Sans le ##, ce serait equivalent a
push_ int(5);
qui poserait probleme.
(La raison pour laquelle j'ai des doutes sur la pertinence de ton exemple
est que je ne vois pas de symbole commencant par . qu'on ait envie de
construire comme cela d'une part et qui soit utilisable dans ce contexte
d'autre part).
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
writes:bonjour
j'aurais voulu comprendre l'utilisation du ##, un exmple:
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
Mauvais exemple, je vois mal dans quel cas l'utiliser.
## fusionne les deux symboles qui l'entoure en un seul. Le cas le plus
courant est pour construire des identificateurs sur base d'une racine
passee en parametre.
Exemple simple
#define PUSH(type, value) push_##type(value)
PUSH(int, 5);
equivaut a
push_int(5);
Sans le ##, ce serait equivalent a
push_ int(5);
qui poserait probleme.
(La raison pour laquelle j'ai des doutes sur la pertinence de ton exemple
est que je ne vois pas de symbole commencant par . qu'on ait envie de
construire comme cela d'une part et qui soit utilisable dans ce contexte
d'autre part).
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas un lexeme
valide pour le langage C.
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas un lexeme
valide pour le langage C.
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas un lexeme
valide pour le langage C.
Marc Espie wrote on 21/01/2008 14:44:#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas un lexeme
valide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Marc Espie wrote on 21/01/2008 14:44:
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas un lexeme
valide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Marc Espie wrote on 21/01/2008 14:44:#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas un lexeme
valide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
In article <4794b148$0$866$,
Sylvain wrote:Marc Espie wrote on 21/01/2008 14:44:#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas un lexeme
valide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Pas plus valide. Tu essaies toujours de recoller des choses qui ne vont
pas former un seul token.
In article <4794b148$0$866$ba4acef3@news.orange.fr>,
Sylvain <noSpam@mail.net> wrote:
Marc Espie wrote on 21/01/2008 14:44:
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas un lexeme
valide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Pas plus valide. Tu essaies toujours de recoller des choses qui ne vont
pas former un seul token.
In article <4794b148$0$866$,
Sylvain wrote:Marc Espie wrote on 21/01/2008 14:44:#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas un lexeme
valide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Pas plus valide. Tu essaies toujours de recoller des choses qui ne vont
pas former un seul token.
Marc Espie wrote on 21/01/2008 15:52:In article <4794b148$0$866$,
Sylvain wrote:Marc Espie wrote on 21/01/2008 14:44:#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas
un lexemevalide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Pas plus valide. Tu essaies toujours de recoller des choses qui ne vont
pas former un seul token.
?!? j'avais oublié le "valide pour le language C" dans ton affirmation.
en C, en effet, un appel comme "instance.foo()" n'est pas valide (une
porte ouverte), mais pour ce forum ce serait bien valide.
Sylvain.
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas
un lexemevalide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Pas plus valide. Tu essaies toujours de recoller des choses qui ne vont
pas former un seul token.
?!? j'avais oublié le "valide pour le language C" dans ton affirmation.
en C, en effet, un appel comme "instance.foo()" n'est pas valide (une
porte ouverte), mais pour ce forum ce serait bien valide.
Sylvain.
Marc Espie wrote on 21/01/2008 15:52:
In article <4794b148$0$866$ba4acef3@news.orange.fr>,
Sylvain <noSpam@mail.net> wrote:
Marc Espie wrote on 21/01/2008 14:44:
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas
un lexeme
valide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Pas plus valide. Tu essaies toujours de recoller des choses qui ne vont
pas former un seul token.
?!? j'avais oublié le "valide pour le language C" dans ton affirmation.
en C, en effet, un appel comme "instance.foo()" n'est pas valide (une
porte ouverte), mais pour ce forum ce serait bien valide.
Sylvain.
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas
un lexeme
valide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Pas plus valide. Tu essaies toujours de recoller des choses qui ne vont
pas former un seul token.
?!? j'avais oublié le "valide pour le language C" dans ton affirmation.
en C, en effet, un appel comme "instance.foo()" n'est pas valide (une
porte ouverte), mais pour ce forum ce serait bien valide.
Sylvain.
Marc Espie wrote on 21/01/2008 15:52:In article <4794b148$0$866$,
Sylvain wrote:Marc Espie wrote on 21/01/2008 14:44:#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas
un lexemevalide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Pas plus valide. Tu essaies toujours de recoller des choses qui ne vont
pas former un seul token.
?!? j'avais oublié le "valide pour le language C" dans ton affirmation.
en C, en effet, un appel comme "instance.foo()" n'est pas valide (une
porte ouverte), mais pour ce forum ce serait bien valide.
Sylvain.
`fonctionnera', mais c'est une erreur. Lors de l'utilisation de cette macro,
un compilateur decent expliquera que .foo (si x vaut foo) n'est pas
un lexemevalide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Pas plus valide. Tu essaies toujours de recoller des choses qui ne vont
pas former un seul token.
?!? j'avais oublié le "valide pour le language C" dans ton affirmation.
en C, en effet, un appel comme "instance.foo()" n'est pas valide (une
porte ouverte), mais pour ce forum ce serait bien valide.
Sylvain.
In article ,
Jean-Marc Bourguet wrote:writes:
Pour bien comprendre ##, il faut voir comment est cense
marcher le compilateur C selon la norme C. Il y a plusieurs
phases: decoupage en lexemes (tokens en anglais), application
du preprocesseur, puis du compilateur.
Le truc essentiel, c'est que le preprocesseur est cense agir sur les token ,
donc entites syntaxiques a part entiere, il n'y a *que* ## qui permet
de recoller des morceaux.
Quelques elements supplementaires:
- en C traditionnel, le preprocesseur travaille sur du texte, et remplace
les commentaires par rien (d'ou le DOUBLE ci-dessus).
- En C ANSI, le preprocesseur travaille sur des lexeme, et remplace un
commentaire par un espace.
- Certaines versions de compilateurs intermediaires (les vieux gcc) ont de s
regles intermediaires: ils reconnaissent ## pour indiquer un bete recollag e,
mais travaillent avec du texte. Sur ces compilateurs,#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur.
Lors de l'utilisation de cette macro, un compilateur decent
expliquera que .foo (si x vaut foo) n'est pas un lexeme valide
pour le langage C.
In article <pxbzluznwfw....@news.bourguet.org>,
Jean-Marc Bourguet <j...@bourguet.org> wrote:
gpgn...@gmail.com writes:
Pour bien comprendre ##, il faut voir comment est cense
marcher le compilateur C selon la norme C. Il y a plusieurs
phases: decoupage en lexemes (tokens en anglais), application
du preprocesseur, puis du compilateur.
Le truc essentiel, c'est que le preprocesseur est cense agir sur les token ,
donc entites syntaxiques a part entiere, il n'y a *que* ## qui permet
de recoller des morceaux.
Quelques elements supplementaires:
- en C traditionnel, le preprocesseur travaille sur du texte, et remplace
les commentaires par rien (d'ou le DOUBLE ci-dessus).
- En C ANSI, le preprocesseur travaille sur des lexeme, et remplace un
commentaire par un espace.
- Certaines versions de compilateurs intermediaires (les vieux gcc) ont de s
regles intermediaires: ils reconnaissent ## pour indiquer un bete recollag e,
mais travaillent avec du texte. Sur ces compilateurs,
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur.
Lors de l'utilisation de cette macro, un compilateur decent
expliquera que .foo (si x vaut foo) n'est pas un lexeme valide
pour le langage C.
In article ,
Jean-Marc Bourguet wrote:writes:
Pour bien comprendre ##, il faut voir comment est cense
marcher le compilateur C selon la norme C. Il y a plusieurs
phases: decoupage en lexemes (tokens en anglais), application
du preprocesseur, puis du compilateur.
Le truc essentiel, c'est que le preprocesseur est cense agir sur les token ,
donc entites syntaxiques a part entiere, il n'y a *que* ## qui permet
de recoller des morceaux.
Quelques elements supplementaires:
- en C traditionnel, le preprocesseur travaille sur du texte, et remplace
les commentaires par rien (d'ou le DOUBLE ci-dessus).
- En C ANSI, le preprocesseur travaille sur des lexeme, et remplace un
commentaire par un espace.
- Certaines versions de compilateurs intermediaires (les vieux gcc) ont de s
regles intermediaires: ils reconnaissent ## pour indiquer un bete recollag e,
mais travaillent avec du texte. Sur ces compilateurs,#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur.
Lors de l'utilisation de cette macro, un compilateur decent
expliquera que .foo (si x vaut foo) n'est pas un lexeme valide
pour le langage C.
Marc Espie wrote on 21/01/2008 15:52:In article <4794b148$0$866$,
Sylvain wrote:Marc Espie wrote on 21/01/2008 14:44:#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de
l'utilisation de cette macro, un compilateur decent
expliquera que .foo (si x vaut foo) n'est pas un lexeme
valide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Pas plus valide. Tu essaies toujours de recoller des choses qui ne vont
pas former un seul token.
?!? j'avais oublié le "valide pour le language C" dans ton affirmation.
en C, en effet, un appel comme "instance.foo()" n'est pas valide (une
porte ouverte), mais pour ce forum ce serait bien valide.
Marc Espie wrote on 21/01/2008 15:52:
In article <4794b148$0$866$ba4ac...@news.orange.fr>,
Sylvain <noS...@mail.net> wrote:
Marc Espie wrote on 21/01/2008 14:44:
#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de
l'utilisation de cette macro, un compilateur decent
expliquera que .foo (si x vaut foo) n'est pas un lexeme
valide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Pas plus valide. Tu essaies toujours de recoller des choses qui ne vont
pas former un seul token.
?!? j'avais oublié le "valide pour le language C" dans ton affirmation.
en C, en effet, un appel comme "instance.foo()" n'est pas valide (une
porte ouverte), mais pour ce forum ce serait bien valide.
Marc Espie wrote on 21/01/2008 15:52:In article <4794b148$0$866$,
Sylvain wrote:Marc Espie wrote on 21/01/2008 14:44:#define MANGLE(x) (OpenGL::GetCurrent(__FILE__, __LINE__)).##x
`fonctionnera', mais c'est une erreur. Lors de
l'utilisation de cette macro, un compilateur decent
expliquera que .foo (si x vaut foo) n'est pas un lexeme
valide pour le langage C.
pourquoi juste "foo", "MANGLE(foo());" serait valide ... pour peu que
l'instance (inconnue) retournée par ce GetCurrent() propose bien une
telle méthode.
Pas plus valide. Tu essaies toujours de recoller des choses qui ne vont
pas former un seul token.
?!? j'avais oublié le "valide pour le language C" dans ton affirmation.
en C, en effet, un appel comme "instance.foo()" n'est pas valide (une
porte ouverte), mais pour ce forum ce serait bien valide.
?!? j'avais oublié le "valide pour le language C" dans ton affirmation.
en C, en effet, un appel comme "instance.foo()" n'est pas valide (une
porte ouverte), mais pour ce forum ce serait bien valide.
À cet égard, égard, le C++ est 100% compatible avec le C.
Autant que je sache, la seule différence entre le préprocesseur
C90 et le préprocesseur C++, c'est que le C++ reconnaît les
commentaires //
[...]
Dans la pratique, les compilateurs travaillent prèsque tous
avec du texte -- même dans le cas de g++, ça ne m'étonnerait
pas qu'à la base, il travaille avec du texte, et ne fait
qu'une vérification supplémentaire exprès pour emmerder le
programmeur/détecter encore des cas d'erreurs potentielles
?!? j'avais oublié le "valide pour le language C" dans ton affirmation.
en C, en effet, un appel comme "instance.foo()" n'est pas valide (une
porte ouverte), mais pour ce forum ce serait bien valide.
À cet égard, égard, le C++ est 100% compatible avec le C.
Autant que je sache, la seule différence entre le préprocesseur
C90 et le préprocesseur C++, c'est que le C++ reconnaît les
commentaires //
[...]
Dans la pratique, les compilateurs travaillent prèsque tous
avec du texte -- même dans le cas de g++, ça ne m'étonnerait
pas qu'à la base, il travaille avec du texte, et ne fait
qu'une vérification supplémentaire exprès pour emmerder le
programmeur/détecter encore des cas d'erreurs potentielles
?!? j'avais oublié le "valide pour le language C" dans ton affirmation.
en C, en effet, un appel comme "instance.foo()" n'est pas valide (une
porte ouverte), mais pour ce forum ce serait bien valide.
À cet égard, égard, le C++ est 100% compatible avec le C.
Autant que je sache, la seule différence entre le préprocesseur
C90 et le préprocesseur C++, c'est que le C++ reconnaît les
commentaires //
[...]
Dans la pratique, les compilateurs travaillent prèsque tous
avec du texte -- même dans le cas de g++, ça ne m'étonnerait
pas qu'à la base, il travaille avec du texte, et ne fait
qu'une vérification supplémentaire exprès pour emmerder le
programmeur/détecter encore des cas d'erreurs potentielles
James Kanze wrote on 21/01/2008 21:15:[...]
Dans la pratique, les compilateurs travaillent prèsque tous
avec du texte -- même dans le cas de g++, ça ne m'étonnerait
pas qu'à la base, il travaille avec du texte, et ne fait
qu'une vérification supplémentaire exprès pour emmerder le
programmeur/détecter encore des cas d'erreurs potentielles
c'est aussi mon expérience et elle permet parfaitement de préprocesser
le MANGLE proposé ... mais je suis prêt à entendre que Marc a raison en
théorie ;)
James Kanze wrote on 21/01/2008 21:15:
[...]
Dans la pratique, les compilateurs travaillent prèsque tous
avec du texte -- même dans le cas de g++, ça ne m'étonnerait
pas qu'à la base, il travaille avec du texte, et ne fait
qu'une vérification supplémentaire exprès pour emmerder le
programmeur/détecter encore des cas d'erreurs potentielles
c'est aussi mon expérience et elle permet parfaitement de préprocesser
le MANGLE proposé ... mais je suis prêt à entendre que Marc a raison en
théorie ;)
James Kanze wrote on 21/01/2008 21:15:[...]
Dans la pratique, les compilateurs travaillent prèsque tous
avec du texte -- même dans le cas de g++, ça ne m'étonnerait
pas qu'à la base, il travaille avec du texte, et ne fait
qu'une vérification supplémentaire exprès pour emmerder le
programmeur/détecter encore des cas d'erreurs potentielles
c'est aussi mon expérience et elle permet parfaitement de préprocesser
le MANGLE proposé ... mais je suis prêt à entendre que Marc a raison en
théorie ;)