Bonjour,
J'aimerai savoir si il exite une directive qui permet au
préprocesseur de prétraiter un fichier deux fois plutôt qu'une avant
compilation.
Et ce pour que le code suivant est un sens (qui ne
fonctionnerai, selon ma compréhension, qu'au deuxième prétraitement)
#define D define
#define foo(x,y) foo_2arg(x,y+NULL)
# D MACONST 0xfff
# D foo_2arg(x,y) foo_2arg_prime( x ## * MACONST, y)
int fct(int * a)
{
return foo(22, a)
}
Dans le cas ou une telle directive n'existe pas, est-ce que il existe
une manière standard ou à défaut, disponible sur tous les
compilateurs, de réclamer une telle opération dans ses fichiers de
configuration?
Une question:
En C++, il existe deux fonctionnalités très intéressantes, soit la
surcharge d'opérateurs et de fonctions. Est-ce que ces
fonctionnalités pourraient être mimés en C?
Bonjour,
J'aimerai savoir si il exite une directive qui permet au
préprocesseur de prétraiter un fichier deux fois plutôt qu'une avant
compilation.
Et ce pour que le code suivant est un sens (qui ne
fonctionnerai, selon ma compréhension, qu'au deuxième prétraitement)
#define D define
#define foo(x,y) foo_2arg(x,y+NULL)
# D MACONST 0xfff
# D foo_2arg(x,y) foo_2arg_prime( x ## * MACONST, y)
int fct(int * a)
{
return foo(22, a)
}
Dans le cas ou une telle directive n'existe pas, est-ce que il existe
une manière standard ou à défaut, disponible sur tous les
compilateurs, de réclamer une telle opération dans ses fichiers de
configuration?
Une question:
En C++, il existe deux fonctionnalités très intéressantes, soit la
surcharge d'opérateurs et de fonctions. Est-ce que ces
fonctionnalités pourraient être mimés en C?
Bonjour,
J'aimerai savoir si il exite une directive qui permet au
préprocesseur de prétraiter un fichier deux fois plutôt qu'une avant
compilation.
Et ce pour que le code suivant est un sens (qui ne
fonctionnerai, selon ma compréhension, qu'au deuxième prétraitement)
#define D define
#define foo(x,y) foo_2arg(x,y+NULL)
# D MACONST 0xfff
# D foo_2arg(x,y) foo_2arg_prime( x ## * MACONST, y)
int fct(int * a)
{
return foo(22, a)
}
Dans le cas ou une telle directive n'existe pas, est-ce que il existe
une manière standard ou à défaut, disponible sur tous les
compilateurs, de réclamer une telle opération dans ses fichiers de
configuration?
Une question:
En C++, il existe deux fonctionnalités très intéressantes, soit la
surcharge d'opérateurs et de fonctions. Est-ce que ces
fonctionnalités pourraient être mimés en C?
Ce charabia n'est pas du C. Il faudrait autre chose que des passes de
preprocessing (au sens C) pour que ça daigne un jour se compiler. Qui
enlevera l'espace entre # et D ? Sans doute pas le prepro. De toutes
façons, il fera dans sa culotte à la première passe.
Ce charabia n'est pas du C. Il faudrait autre chose que des passes de
preprocessing (au sens C) pour que ça daigne un jour se compiler. Qui
enlevera l'espace entre # et D ? Sans doute pas le prepro. De toutes
façons, il fera dans sa culotte à la première passe.
Ce charabia n'est pas du C. Il faudrait autre chose que des passes de
preprocessing (au sens C) pour que ça daigne un jour se compiler. Qui
enlevera l'espace entre # et D ? Sans doute pas le prepro. De toutes
façons, il fera dans sa culotte à la première passe.
Ce charabia n'est pas du C. Il faudrait autre chose que des passes de
preprocessing (au sens C) pour que ça daigne un jour se compiler. Qui
enlevera l'espace entre # et D ? Sans doute pas le prepro. De toutes
façons, il fera dans sa culotte à la première passe.
L'espace entre le # et D est heureusement permis dans le C standard.
Ce charabia n'est pas du C. Il faudrait autre chose que des passes de
preprocessing (au sens C) pour que ça daigne un jour se compiler. Qui
enlevera l'espace entre # et D ? Sans doute pas le prepro. De toutes
façons, il fera dans sa culotte à la première passe.
L'espace entre le # et D est heureusement permis dans le C standard.
Ce charabia n'est pas du C. Il faudrait autre chose que des passes de
preprocessing (au sens C) pour que ça daigne un jour se compiler. Qui
enlevera l'espace entre # et D ? Sans doute pas le prepro. De toutes
façons, il fera dans sa culotte à la première passe.
L'espace entre le # et D est heureusement permis dans le C standard.
J'aimerai savoir si il exite une directive qui permet au
préprocesseur de prétraiter un fichier deux fois plutôt qu'une avant
compilation.
Et ce pour que le code suivant est un sens (qui ne
fonctionnerai, selon ma compréhension, qu'au deuxième prétraitement)
#define D define
#define foo(x,y) foo_2arg(x,y+NULL)
# D MACONST 0xfff
# D foo_2arg(x,y) foo_2arg_prime( x ## * MACONST, y)
int fct(int * a)
{
return foo(22, a)
}
Dans le cas ou une telle directive n'existe pas, est-ce que il existe
une manière standard
ou à défaut, disponible sur tous les compilateurs,
Une question: En C++,
J'aimerai savoir si il exite une directive qui permet au
préprocesseur de prétraiter un fichier deux fois plutôt qu'une avant
compilation.
Et ce pour que le code suivant est un sens (qui ne
fonctionnerai, selon ma compréhension, qu'au deuxième prétraitement)
#define D define
#define foo(x,y) foo_2arg(x,y+NULL)
# D MACONST 0xfff
# D foo_2arg(x,y) foo_2arg_prime( x ## * MACONST, y)
int fct(int * a)
{
return foo(22, a)
}
Dans le cas ou une telle directive n'existe pas, est-ce que il existe
une manière standard
ou à défaut, disponible sur tous les compilateurs,
Une question: En C++,
J'aimerai savoir si il exite une directive qui permet au
préprocesseur de prétraiter un fichier deux fois plutôt qu'une avant
compilation.
Et ce pour que le code suivant est un sens (qui ne
fonctionnerai, selon ma compréhension, qu'au deuxième prétraitement)
#define D define
#define foo(x,y) foo_2arg(x,y+NULL)
# D MACONST 0xfff
# D foo_2arg(x,y) foo_2arg_prime( x ## * MACONST, y)
int fct(int * a)
{
return foo(22, a)
}
Dans le cas ou une telle directive n'existe pas, est-ce que il existe
une manière standard
ou à défaut, disponible sur tous les compilateurs,
Une question: En C++,
Si tu utilises GCC :
man cpp
Si tu utilises GCC :
man cpp
Si tu utilises GCC :
man cpp
J'aimerai savoir si il exite une directive qui permet au
préprocesseur de prétraiter un fichier deux fois plutôt qu'une av ant
compilation.Normalement non.
Et ce pour que le code suivant est un sens (qui ne
fonctionnerai, selon ma compréhension, qu'au deuxième prétraiteme nt)Pas d'accord.
#define D define
#define foo(x,y) foo_2arg(x,y+NULL)
# D MACONST 0xfffÀ la première passe, cela va être refusé tout net (la directive "D" n'existe
pas en C).
Si tu veux jouer au plus malin, tu peux essayer des trucs comme
?
?= D MACONST 0xfff
mais c'est parfaitement affreux, ÀMHA.
(avec une erreur de compilation à la clé avant le dernier lexème), je ne
vois pas l'intérêt de cette complexité : tu mets define à la plac e D, et
cela marche tout seul.
Si tu veux arriver à autre chose, merci d'expliciter.
ou à défaut, disponible sur tous les compilateurs,Absolument imposs ible et irréaliste : un grand nombre de compilateurs à
l'heure actuelle n'ont même plus de préprocesseurs séparés !
Architecturellement, la distinction avait une certaine logique à l'ép oque de
V7, c'est-à-dire vers 1978. Mais c'était il y a 30 ans ! (pour un lan gage
qui en a 35).
Aujourd'hui, cette histoire du préprocesseur de macros séparé est u n acquis
historique du langage C que l'on ne peut plus effacer et qu'il faut subir en
silence ; mais vouloir jouer à des subtilités avec relève de l'amus ement,
pas de la portabilité « sur tous les compilateurs ».
J'aimerai savoir si il exite une directive qui permet au
préprocesseur de prétraiter un fichier deux fois plutôt qu'une av ant
compilation.Normalement non.
Et ce pour que le code suivant est un sens (qui ne
fonctionnerai, selon ma compréhension, qu'au deuxième prétraiteme nt)Pas d'accord.
#define D define
#define foo(x,y) foo_2arg(x,y+NULL)
# D MACONST 0xfffÀ la première passe, cela va être refusé tout net (la directive "D" n'existe
pas en C).
Si tu veux jouer au plus malin, tu peux essayer des trucs comme
?
?= D MACONST 0xfff
mais c'est parfaitement affreux, ÀMHA.
(avec une erreur de compilation à la clé avant le dernier lexème), je ne
vois pas l'intérêt de cette complexité : tu mets define à la plac e D, et
cela marche tout seul.
Si tu veux arriver à autre chose, merci d'expliciter.
ou à défaut, disponible sur tous les compilateurs,Absolument imposs ible et irréaliste : un grand nombre de compilateurs à
l'heure actuelle n'ont même plus de préprocesseurs séparés !
Architecturellement, la distinction avait une certaine logique à l'ép oque de
V7, c'est-à-dire vers 1978. Mais c'était il y a 30 ans ! (pour un lan gage
qui en a 35).
Aujourd'hui, cette histoire du préprocesseur de macros séparé est u n acquis
historique du langage C que l'on ne peut plus effacer et qu'il faut subir en
silence ; mais vouloir jouer à des subtilités avec relève de l'amus ement,
pas de la portabilité « sur tous les compilateurs ».
J'aimerai savoir si il exite une directive qui permet au
préprocesseur de prétraiter un fichier deux fois plutôt qu'une av ant
compilation.Normalement non.
Et ce pour que le code suivant est un sens (qui ne
fonctionnerai, selon ma compréhension, qu'au deuxième prétraiteme nt)Pas d'accord.
#define D define
#define foo(x,y) foo_2arg(x,y+NULL)
# D MACONST 0xfffÀ la première passe, cela va être refusé tout net (la directive "D" n'existe
pas en C).
Si tu veux jouer au plus malin, tu peux essayer des trucs comme
?
?= D MACONST 0xfff
mais c'est parfaitement affreux, ÀMHA.
(avec une erreur de compilation à la clé avant le dernier lexème), je ne
vois pas l'intérêt de cette complexité : tu mets define à la plac e D, et
cela marche tout seul.
Si tu veux arriver à autre chose, merci d'expliciter.
ou à défaut, disponible sur tous les compilateurs,Absolument imposs ible et irréaliste : un grand nombre de compilateurs à
l'heure actuelle n'ont même plus de préprocesseurs séparés !
Architecturellement, la distinction avait une certaine logique à l'ép oque de
V7, c'est-à-dire vers 1978. Mais c'était il y a 30 ans ! (pour un lan gage
qui en a 35).
Aujourd'hui, cette histoire du préprocesseur de macros séparé est u n acquis
historique du langage C que l'on ne peut plus effacer et qu'il faut subir en
silence ; mais vouloir jouer à des subtilités avec relève de l'amus ement,
pas de la portabilité « sur tous les compilateurs ».
http://www.duckware.com/bugfreec/chapter2.html
--------------------
2.2.9 Preprocessor Commands Containing Preprocessor Commands
Have you ever wanted to write a macro that referred to another
preprocessing directive? Consider the following example.
Optimize On/Off macros, which do not work
#define OPTIMIZEOFF #pragma optimize("",off)
#define OPTIMIZEON #pragma optimize("",on)
http://www.duckware.com/bugfreec/chapter2.html
--------------------
2.2.9 Preprocessor Commands Containing Preprocessor Commands
Have you ever wanted to write a macro that referred to another
preprocessing directive? Consider the following example.
Optimize On/Off macros, which do not work
#define OPTIMIZEOFF #pragma optimize("",off)
#define OPTIMIZEON #pragma optimize("",on)
http://www.duckware.com/bugfreec/chapter2.html
--------------------
2.2.9 Preprocessor Commands Containing Preprocessor Commands
Have you ever wanted to write a macro that referred to another
preprocessing directive? Consider the following example.
Optimize On/Off macros, which do not work
#define OPTIMIZEOFF #pragma optimize("",off)
#define OPTIMIZEON #pragma optimize("",on)
On 24 jan, 09:53, "Antoine Leca" wrote:Et ce pour que le code suivant est un sens (qui ne
fonctionnerai, selon ma compréhension, qu'au deuxième
prétraitement)
Pas d'accord.
Si on peut prétraiter récursivement, on peut faire a peu près
n'importe quoi en autant que l'exécution du programme contrôlant le
préprocesseur se termine complêtement, écrit au fichier, puis
redémarre. Tel que vu, dans les concours de l'IOCCC, ça fonctionne
bien.
Maintenant désolé de devoir saluer un tel standard.
#define D define
# D MACONST 0xfff
À la première passe, cela va être refusé tout net
(la directive "D" n'existe pas en C).
Encore une fois, tel que vu dans les concours de l'IOCCC, # D sera
ignoré par le préprocesseur
[...] silencieusement
Si tu veux arriver à autre chose, merci d'expliciter.
En pouvant utiliser un outils standard reconnu comme le
préprocesseur, (même si cela devait conduire à spécifier des
paramètres particuliers à chaque environnement de dévellopement) on
pourrait écrire une/des entêtes qui émule la surcharge d'opérateurs
ou de fonctions en C par exemple... (de façon transparente à
l'utilisateur)
On 24 jan, 09:53, "Antoine Leca" <r...@localhost.invalid> wrote:
Et ce pour que le code suivant est un sens (qui ne
fonctionnerai, selon ma compréhension, qu'au deuxième
prétraitement)
Pas d'accord.
Si on peut prétraiter récursivement, on peut faire a peu près
n'importe quoi en autant que l'exécution du programme contrôlant le
préprocesseur se termine complêtement, écrit au fichier, puis
redémarre. Tel que vu, dans les concours de l'IOCCC, ça fonctionne
bien.
Maintenant désolé de devoir saluer un tel standard.
#define D define
# D MACONST 0xfff
À la première passe, cela va être refusé tout net
(la directive "D" n'existe pas en C).
Encore une fois, tel que vu dans les concours de l'IOCCC, # D sera
ignoré par le préprocesseur
[...] silencieusement
Si tu veux arriver à autre chose, merci d'expliciter.
En pouvant utiliser un outils standard reconnu comme le
préprocesseur, (même si cela devait conduire à spécifier des
paramètres particuliers à chaque environnement de dévellopement) on
pourrait écrire une/des entêtes qui émule la surcharge d'opérateurs
ou de fonctions en C par exemple... (de façon transparente à
l'utilisateur)
On 24 jan, 09:53, "Antoine Leca" wrote:Et ce pour que le code suivant est un sens (qui ne
fonctionnerai, selon ma compréhension, qu'au deuxième
prétraitement)
Pas d'accord.
Si on peut prétraiter récursivement, on peut faire a peu près
n'importe quoi en autant que l'exécution du programme contrôlant le
préprocesseur se termine complêtement, écrit au fichier, puis
redémarre. Tel que vu, dans les concours de l'IOCCC, ça fonctionne
bien.
Maintenant désolé de devoir saluer un tel standard.
#define D define
# D MACONST 0xfff
À la première passe, cela va être refusé tout net
(la directive "D" n'existe pas en C).
Encore une fois, tel que vu dans les concours de l'IOCCC, # D sera
ignoré par le préprocesseur
[...] silencieusement
Si tu veux arriver à autre chose, merci d'expliciter.
En pouvant utiliser un outils standard reconnu comme le
préprocesseur, (même si cela devait conduire à spécifier des
paramètres particuliers à chaque environnement de dévellopement) on
pourrait écrire une/des entêtes qui émule la surcharge d'opérateurs
ou de fonctions en C par exemple... (de façon transparente à
l'utilisateur)
C>man cpp
"man" no se reconoce como un comando interno o externo,
programa o archivo por lotes ejecutable.
C>man cpp
"man" no se reconoce como un comando interno o externo,
programa o archivo por lotes ejecutable.
C>man cpp
"man" no se reconoce como un comando interno o externo,
programa o archivo por lotes ejecutable.