Marchera pas sur 95% des compilos: le préprocesseur ne fait qu'une passe, et donc il ne réévaluera pas la dièse même si vous arrivez à la faire générer. C'est pas faute d'avoir essayé :o)
Y-a-t-il un moyen,
Pas exactement comme ça, mais j'ai trouvé comment inclure des pragmas (non portables) de manière portable, conditionnelle et éventuellement transformiste.
Je donnais récemment un exemple dans le fil "support des types enums compacts", le 14/06 (réponse à James Kanze).
Hope it helps.
-- Cordialement. -- /************************************************** * Patrick BRUNET * E-mail: lien sur http://zener131.free.fr/ContactMe **************************************************/
Bonsoir.
"thierry nivon" <thierry.nivon@wanadoo.fr> a écrit dans le message news:
46801118$0$25945$ba4acef3@news.orange.fr...
Bonjour,
je voudrais pouvoir faire un define comme suit
Marchera pas sur 95% des compilos: le préprocesseur ne fait qu'une passe, et
donc il ne réévaluera pas la dièse même si vous arrivez à la faire générer.
C'est pas faute d'avoir essayé :o)
Y-a-t-il un moyen,
Pas exactement comme ça, mais j'ai trouvé comment inclure des pragmas (non
portables) de manière portable, conditionnelle et éventuellement
transformiste.
Je donnais récemment un exemple dans le fil "support des types enums
compacts", le 14/06 (réponse à James Kanze).
Hope it helps.
--
Cordialement.
--
/**************************************************
* Patrick BRUNET
* E-mail: lien sur http://zener131.free.fr/ContactMe
**************************************************/
Marchera pas sur 95% des compilos: le préprocesseur ne fait qu'une passe, et donc il ne réévaluera pas la dièse même si vous arrivez à la faire générer. C'est pas faute d'avoir essayé :o)
Y-a-t-il un moyen,
Pas exactement comme ça, mais j'ai trouvé comment inclure des pragmas (non portables) de manière portable, conditionnelle et éventuellement transformiste.
Je donnais récemment un exemple dans le fil "support des types enums compacts", le 14/06 (réponse à James Kanze).
Hope it helps.
-- Cordialement. -- /************************************************** * Patrick BRUNET * E-mail: lien sur http://zener131.free.fr/ContactMe **************************************************/
thierry nivon
Bonsoir.
"thierry nivon" a écrit dans le message news: 46801118$0$25945$
Bonjour, je voudrais pouvoir faire un define comme suit
Marchera pas sur 95% des compilos: le préprocesseur ne fait qu'une passe, et donc il ne réévaluera pas la dièse même si vous arrivez à la faire générer. C'est pas faute d'avoir essayé :o)
Y-a-t-il un moyen,
Pas exactement comme ça, mais j'ai trouvé comment inclure des pragmas (non portables) de manière portable, conditionnelle et éventuellement transformiste.
Je donnais récemment un exemple dans le fil "support des types enums compacts", le 14/06 (réponse à James Kanze).
Hope it helps.
-- Cordialement. -- /************************************************** * Patrick BRUNET * E-mail: lien sur http://zener131.free.fr/ContactMe **************************************************/
Merci, effectivement j'ai lu juste après que gcc ne le permettait pas mais j'ai trouvé __attribute__((unused)) Thierry
Bonsoir.
"thierry nivon" <thierry.nivon@wanadoo.fr> a écrit dans le message news:
46801118$0$25945$ba4acef3@news.orange.fr...
Bonjour,
je voudrais pouvoir faire un define comme suit
Marchera pas sur 95% des compilos: le préprocesseur ne fait qu'une passe, et
donc il ne réévaluera pas la dièse même si vous arrivez à la faire générer.
C'est pas faute d'avoir essayé :o)
Y-a-t-il un moyen,
Pas exactement comme ça, mais j'ai trouvé comment inclure des pragmas (non
portables) de manière portable, conditionnelle et éventuellement
transformiste.
Je donnais récemment un exemple dans le fil "support des types enums
compacts", le 14/06 (réponse à James Kanze).
Hope it helps.
--
Cordialement.
--
/**************************************************
* Patrick BRUNET
* E-mail: lien sur http://zener131.free.fr/ContactMe
**************************************************/
Merci,
effectivement j'ai lu juste après que gcc ne le permettait pas
mais j'ai trouvé __attribute__((unused))
Thierry
Marchera pas sur 95% des compilos: le préprocesseur ne fait qu'une passe, et donc il ne réévaluera pas la dièse même si vous arrivez à la faire générer. C'est pas faute d'avoir essayé :o)
Y-a-t-il un moyen,
Pas exactement comme ça, mais j'ai trouvé comment inclure des pragmas (non portables) de manière portable, conditionnelle et éventuellement transformiste.
Je donnais récemment un exemple dans le fil "support des types enums compacts", le 14/06 (réponse à James Kanze).
Hope it helps.
-- Cordialement. -- /************************************************** * Patrick BRUNET * E-mail: lien sur http://zener131.free.fr/ContactMe **************************************************/
Merci, effectivement j'ai lu juste après que gcc ne le permettait pas mais j'ai trouvé __attribute__((unused)) Thierry
Sylvain
thierry nivon wrote on 25/06/2007 21:01:
Bonjour, je voudrais pouvoir faire un define comme suit
un fil un peu ressemblant court sur fclc où l'on pourrait soutenir qu'en C K&R on n'a pas d'autre choix que de déclarer des paramètres formels pour les ignorer ensuite.
mais, en C++, je ne vois aucune raison (hormis le verbiage) de déclarer quelque chose comme:
type foo(type1 param1, type2 param2) { UNUSED_PARAMETER(param2) ... }
quand le bon sens, la lisibilité, la simplicité d'écriture même impose
type foo(type1 param1, type2) { ... }
j'ai loupé qlq chose où certains code sont encore évalués à leur nombre de caractères (inutiles) ?
Sylvain.
thierry nivon wrote on 25/06/2007 21:01:
Bonjour,
je voudrais pouvoir faire un define comme suit
un fil un peu ressemblant court sur fclc où l'on pourrait soutenir qu'en
C K&R on n'a pas d'autre choix que de déclarer des paramètres formels
pour les ignorer ensuite.
mais, en C++, je ne vois aucune raison (hormis le verbiage) de déclarer
quelque chose comme:
type foo(type1 param1, type2 param2)
{
UNUSED_PARAMETER(param2)
...
}
quand le bon sens, la lisibilité, la simplicité d'écriture même impose
type foo(type1 param1, type2)
{
...
}
j'ai loupé qlq chose où certains code sont encore évalués à leur nombre
de caractères (inutiles) ?
un fil un peu ressemblant court sur fclc où l'on pourrait soutenir qu'en C K&R on n'a pas d'autre choix que de déclarer des paramètres formels pour les ignorer ensuite.
mais, en C++, je ne vois aucune raison (hormis le verbiage) de déclarer quelque chose comme:
type foo(type1 param1, type2 param2) { UNUSED_PARAMETER(param2) ... }
quand le bon sens, la lisibilité, la simplicité d'écriture même impose
type foo(type1 param1, type2) { ... }
j'ai loupé qlq chose où certains code sont encore évalués à leur nombre de caractères (inutiles) ?
Pas avec un compilateur conforme. En ce qui concerne l'évaluation d'un macro : « The resulting completely macro-replaced preprocessing token sequence is not processed as a preprocessing directive even if it resembles one. »
Dans C99, ainsi que dans le dernier brouillon de la norme, il y a un opérateur _Pragma qui pourrait servir. À condition que ton compilateur le supporte. G++ le supporte, donc :
-- James Kanze (GABI Software, from CAI) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
On Jun 25, 9:01 pm, thierry nivon <thierry.ni...@wanadoo.fr> wrote:
Pas avec un compilateur conforme. En ce qui concerne
l'évaluation d'un macro : « The resulting completely
macro-replaced preprocessing token sequence is not processed as
a preprocessing directive even if it resembles one. »
Dans C99, ainsi que dans le dernier brouillon de la norme, il y
a un opérateur _Pragma qui pourrait servir. À condition que ton
compilateur le supporte. G++ le supporte, donc :
--
James Kanze (GABI Software, from CAI) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Pas avec un compilateur conforme. En ce qui concerne l'évaluation d'un macro : « The resulting completely macro-replaced preprocessing token sequence is not processed as a preprocessing directive even if it resembles one. »
Dans C99, ainsi que dans le dernier brouillon de la norme, il y a un opérateur _Pragma qui pourrait servir. À condition que ton compilateur le supporte. G++ le supporte, donc :
-- James Kanze (GABI Software, from CAI) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Patrick 'Zener' Brunet
Bonsoir.
"thierry nivon" a écrit dans le message news: 46801be0$0$25945$
"thierry nivon" a écrit dans le message news: 46801118$0$25945$
Bonjour, je voudrais pouvoir faire un define comme suit
Marchera pas sur 95% des compilos: le préprocesseur ne fait qu'une passe, et
donc il ne réévaluera pas la dièse même si vous arrivez à la faire générer.
C'est pas faute d'avoir essayé :o)
Y-a-t-il un moyen,
Pas exactement comme ça, mais j'ai trouvé comment inclure des pragmas (non
portables) de manière portable, conditionnelle et éventuellement transformiste.
Je donnais récemment un exemple dans le fil "support des types enums compacts", le 14/06 (réponse à James Kanze).
Merci, effectivement j'ai lu juste après que gcc ne le permettait pas mais j'ai trouvé __attribute__((unused))
Pas forcément portable...
En fait j'avais répondu sur le principe du #pragma facilement substituable, donc intégrable dans du code portable...
Mais pour les paramètres inutilisés, pourquoi pas le traditionnel:
(void) unused;
...qui, même s'il introduit un peu de texte supplémentaire, présente l'avantage de la clarté au sens sémantique ?
Si les paramètres superflus sont un reliquat de vieux codage, ils doivent plutôt être supprimés, mais généralement ils subsistent car le format de la fonction les impose. Autant le montrer.
Au risque de paraître pervers, je trouve même ça plus lisible que l'option de Sylvain consistant à ne pas les nommer ! Au risque de se demander à la relecture s'il ne s'agit pas d'une erreur.
-- Cordialement. -- /************************************************** * Patrick BRUNET * E-mail: lien sur http://zener131.free.fr/ContactMe **************************************************/
Bonsoir.
"thierry nivon" <thierry.nivon@wanadoo.fr> a écrit dans le message news:
46801be0$0$25945$ba4acef3@news.orange.fr...
"thierry nivon" <thierry.nivon@wanadoo.fr> a écrit dans le message news:
46801118$0$25945$ba4acef3@news.orange.fr...
Bonjour,
je voudrais pouvoir faire un define comme suit
Marchera pas sur 95% des compilos: le préprocesseur ne fait qu'une
passe, et
donc il ne réévaluera pas la dièse même si vous arrivez à la faire
générer.
C'est pas faute d'avoir essayé :o)
Y-a-t-il un moyen,
Pas exactement comme ça, mais j'ai trouvé comment inclure des pragmas
(non
portables) de manière portable, conditionnelle et éventuellement
transformiste.
Je donnais récemment un exemple dans le fil "support des types enums
compacts", le 14/06 (réponse à James Kanze).
Merci,
effectivement j'ai lu juste après que gcc ne le permettait pas
mais j'ai trouvé __attribute__((unused))
Pas forcément portable...
En fait j'avais répondu sur le principe du #pragma facilement substituable,
donc intégrable dans du code portable...
Mais pour les paramètres inutilisés, pourquoi pas le traditionnel:
(void) unused;
...qui, même s'il introduit un peu de texte supplémentaire, présente
l'avantage de la clarté au sens sémantique ?
Si les paramètres superflus sont un reliquat de vieux codage, ils doivent
plutôt être supprimés, mais généralement ils subsistent car le format de la
fonction les impose. Autant le montrer.
Au risque de paraître pervers, je trouve même ça plus lisible que l'option
de Sylvain consistant à ne pas les nommer ! Au risque de se demander à la
relecture s'il ne s'agit pas d'une erreur.
--
Cordialement.
--
/**************************************************
* Patrick BRUNET
* E-mail: lien sur http://zener131.free.fr/ContactMe
**************************************************/
Marchera pas sur 95% des compilos: le préprocesseur ne fait qu'une passe, et
donc il ne réévaluera pas la dièse même si vous arrivez à la faire générer.
C'est pas faute d'avoir essayé :o)
Y-a-t-il un moyen,
Pas exactement comme ça, mais j'ai trouvé comment inclure des pragmas (non
portables) de manière portable, conditionnelle et éventuellement transformiste.
Je donnais récemment un exemple dans le fil "support des types enums compacts", le 14/06 (réponse à James Kanze).
Merci, effectivement j'ai lu juste après que gcc ne le permettait pas mais j'ai trouvé __attribute__((unused))
Pas forcément portable...
En fait j'avais répondu sur le principe du #pragma facilement substituable, donc intégrable dans du code portable...
Mais pour les paramètres inutilisés, pourquoi pas le traditionnel:
(void) unused;
...qui, même s'il introduit un peu de texte supplémentaire, présente l'avantage de la clarté au sens sémantique ?
Si les paramètres superflus sont un reliquat de vieux codage, ils doivent plutôt être supprimés, mais généralement ils subsistent car le format de la fonction les impose. Autant le montrer.
Au risque de paraître pervers, je trouve même ça plus lisible que l'option de Sylvain consistant à ne pas les nommer ! Au risque de se demander à la relecture s'il ne s'agit pas d'une erreur.
-- Cordialement. -- /************************************************** * Patrick BRUNET * E-mail: lien sur http://zener131.free.fr/ContactMe **************************************************/
