je définis une fonction qui doit en fonction d'une define de compilation
fait rien ou qqchose genre :
#ifdef DOIT_TRAVAILLER
inline void Travail(char * format, ...)
{
// Tout le toutim
}
#else
inline void Travail(char * format, ...)
{
}
#endif
Ca marche a un detail pret.
si DOIT_TRAVAILLER n'est pas définis
et que j'appelle
Travail( "%d\n", MaFonctionQuiFaitUnCalcul() );
Meme si rien n'est produit a l'ecran, la fonction qui fait le calcul
est appelée et travail pour rien. J'aimerais coder une sorte
de assert dependant de mon define.
"Dominique Vaufreydaz" a écrit dans le message de news:
Bonjour,
je définis une fonction qui doit en fonction d'une define de compilation fait rien ou qqchose genre :
#ifdef DOIT_TRAVAILLER inline void Travail(char * format, ...) { // Tout le toutim } #else inline void Travail(char * format, ...) { } #endif
Ca marche a un detail pret. si DOIT_TRAVAILLER n'est pas définis et que j'appelle
Travail( "%dn", MaFonctionQuiFaitUnCalcul() );
Meme si rien n'est produit a l'ecran, la fonction qui fait le calcul est appelée et travail pour rien. J'aimerais coder une sorte de assert dependant de mon define.
QQun a une idée ? Doms.
Peut-être qu'une autre macro : #ifdef DOIT_TRAVAILLER inline void Travail(char * format, ...) { // Tout le toutim } #define TRAVAIL(a,b) Travail(a,b) #else inline void Travail(char * format, ...) { } #define TRAVAIL(a,b) #endif
Et à l'utilisation : TRAVAIL( "%dn", MaFonctionQuiFaitUnCalcul() );
Mais ça nécessite de recompiler les classes utilisatrices quand on modifie la valeur de DOIT_TRAVAILLER.
Selon les cas, on peut aussi se passer des deux définitions de Travail puisque si on l'appelle toujours via la macro TRAVAIL, elle n'est même plus utilisée lorsqu'in n'y en a pas besoin.
"Dominique Vaufreydaz" <Doms@invalid> a écrit dans le message de news:
ed9njo.d30.1@invalid.net...
Bonjour,
je définis une fonction qui doit en fonction d'une define de
compilation
fait rien ou qqchose genre :
#ifdef DOIT_TRAVAILLER
inline void Travail(char * format, ...)
{
// Tout le toutim
}
#else
inline void Travail(char * format, ...)
{
}
#endif
Ca marche a un detail pret.
si DOIT_TRAVAILLER n'est pas définis
et que j'appelle
Travail( "%dn", MaFonctionQuiFaitUnCalcul() );
Meme si rien n'est produit a l'ecran, la fonction qui fait le calcul
est appelée et travail pour rien. J'aimerais coder une sorte
de assert dependant de mon define.
QQun a une idée ? Doms.
Peut-être qu'une autre macro :
#ifdef DOIT_TRAVAILLER
inline void Travail(char * format, ...)
{
// Tout le toutim
}
#define TRAVAIL(a,b) Travail(a,b)
#else
inline void Travail(char * format, ...)
{
}
#define TRAVAIL(a,b)
#endif
Et à l'utilisation :
TRAVAIL( "%dn", MaFonctionQuiFaitUnCalcul() );
Mais ça nécessite de recompiler les classes utilisatrices quand on modifie
la valeur de DOIT_TRAVAILLER.
Selon les cas, on peut aussi se passer des deux définitions de Travail
puisque si on l'appelle toujours via la macro TRAVAIL, elle n'est même plus
utilisée lorsqu'in n'y en a pas besoin.
"Dominique Vaufreydaz" a écrit dans le message de news:
Bonjour,
je définis une fonction qui doit en fonction d'une define de compilation fait rien ou qqchose genre :
#ifdef DOIT_TRAVAILLER inline void Travail(char * format, ...) { // Tout le toutim } #else inline void Travail(char * format, ...) { } #endif
Ca marche a un detail pret. si DOIT_TRAVAILLER n'est pas définis et que j'appelle
Travail( "%dn", MaFonctionQuiFaitUnCalcul() );
Meme si rien n'est produit a l'ecran, la fonction qui fait le calcul est appelée et travail pour rien. J'aimerais coder une sorte de assert dependant de mon define.
QQun a une idée ? Doms.
Peut-être qu'une autre macro : #ifdef DOIT_TRAVAILLER inline void Travail(char * format, ...) { // Tout le toutim } #define TRAVAIL(a,b) Travail(a,b) #else inline void Travail(char * format, ...) { } #define TRAVAIL(a,b) #endif
Et à l'utilisation : TRAVAIL( "%dn", MaFonctionQuiFaitUnCalcul() );
Mais ça nécessite de recompiler les classes utilisatrices quand on modifie la valeur de DOIT_TRAVAILLER.
Selon les cas, on peut aussi se passer des deux définitions de Travail puisque si on l'appelle toujours via la macro TRAVAIL, elle n'est même plus utilisée lorsqu'in n'y en a pas besoin.
Dominique Vaufreydaz
Bonjour,
C'est normal, les paramètres de la fonction sont évalués avant qu'elle ne soit appelée
Eh ouai, c'est d'ailleurs mieux ainsi ;-P
La seule solution que je connaisse consiste à mettre la directive de compilation au niveau supérieur:
je définis une fonction qui doit en fonction d'une define de compilation fait rien ou qqchose genre :
#ifdef DOIT_TRAVAILLER inline void Travail(char * format, ...) { // Tout le toutim } #else inline void Travail(char * format, ...) { } #endif
Ca marche a un detail pret. si DOIT_TRAVAILLER n'est pas définis et que j'appelle
Travail( "%dn", MaFonctionQuiFaitUnCalcul() );
Meme si rien n'est produit a l'ecran, la fonction qui fait le calcul est appelée et travail pour rien. J'aimerais coder une sorte de assert dependant de mon define.
Bonjour,
C'est normal, les paramètres de la fonction sont évalués avant qu'elle ne soit appelée
La seule solution que je connaisse consiste à mettre la directive de compilation au niveau supérieur:
je définis une fonction qui doit en fonction d'une define de compilation
fait rien ou qqchose genre :
#ifdef DOIT_TRAVAILLER
inline void Travail(char * format, ...)
{
// Tout le toutim
}
#else
inline void Travail(char * format, ...)
{
}
#endif
Ca marche a un detail pret.
si DOIT_TRAVAILLER n'est pas définis
et que j'appelle
Travail( "%dn", MaFonctionQuiFaitUnCalcul() );
Meme si rien n'est produit a l'ecran, la fonction qui fait le calcul
est appelée et travail pour rien. J'aimerais coder une sorte
de assert dependant de mon define.
Bonjour,
C'est normal, les paramètres de la fonction sont évalués avant qu'elle
ne soit appelée
La seule solution que je connaisse consiste à mettre la directive de
compilation au niveau supérieur:
je définis une fonction qui doit en fonction d'une define de compilation fait rien ou qqchose genre :
#ifdef DOIT_TRAVAILLER inline void Travail(char * format, ...) { // Tout le toutim } #else inline void Travail(char * format, ...) { } #endif
Ca marche a un detail pret. si DOIT_TRAVAILLER n'est pas définis et que j'appelle
Travail( "%dn", MaFonctionQuiFaitUnCalcul() );
Meme si rien n'est produit a l'ecran, la fonction qui fait le calcul est appelée et travail pour rien. J'aimerais coder une sorte de assert dependant de mon define.
Bonjour,
C'est normal, les paramètres de la fonction sont évalués avant qu'elle ne soit appelée
La seule solution que je connaisse consiste à mettre la directive de compilation au niveau supérieur:
je définis une fonction qui doit en fonction d'une define de compilation fait rien ou qqchose genre :
#ifdef DOIT_TRAVAILLER inline void Travail(char * format, ...) { // Tout le toutim } #else inline void Travail(char * format, ...) { } #endif
Ca marche a un detail pret. si DOIT_TRAVAILLER n'est pas définis et que j'appelle
Travail( "%dn", MaFonctionQuiFaitUnCalcul() );
Meme si rien n'est produit a l'ecran, la fonction qui fait le calcul est appelée et travail pour rien. J'aimerais coder une sorte de assert dependant de mon define.
Comme l'a dit Pierre, les parametres de la fonction sont evalues avant l'appel de celle ci (c'est pas vraiment surprenant). Pour eviter l'evaluation, il suffit de ne pas appeler la fonction, puisque de toute facon quand on ne doit pas travailler, la fonction Travail et vide.
Il y a une methode classique qui consiste a placer l'appel de la fonction dans l'alternative d'un if, avec dans le test un drapeau qui evalue a vrai si on ne doit pas appeler la fonction, et faux sinon. En gros, ca ressemble a ca:
et ensuite, tu appelle la fonction Travail comme ceci:
TRAVAIL("%dn", MaFonctionQuiFaitUnCalcul() );
Bonjour,
je définis une fonction qui doit en fonction d'une define de compilation
fait rien ou qqchose genre :
#ifdef DOIT_TRAVAILLER
inline void Travail(char * format, ...)
{
// Tout le toutim
}
#else
inline void Travail(char * format, ...)
{
}
#endif
Ca marche a un detail pret.
si DOIT_TRAVAILLER n'est pas définis
et que j'appelle
Travail( "%dn", MaFonctionQuiFaitUnCalcul() );
Meme si rien n'est produit a l'ecran, la fonction qui fait le calcul
est appelée et travail pour rien. J'aimerais coder une sorte
de assert dependant de mon define.
Comme l'a dit Pierre, les parametres de la fonction sont evalues
avant l'appel de celle ci (c'est pas vraiment surprenant). Pour
eviter l'evaluation, il suffit de ne pas appeler la fonction, puisque
de toute facon quand on ne doit pas travailler, la fonction Travail
et vide.
Il y a une methode classique qui consiste a placer l'appel de la
fonction dans l'alternative d'un if, avec dans le test un drapeau
qui evalue a vrai si on ne doit pas appeler la fonction, et faux
sinon.
En gros, ca ressemble a ca:
je définis une fonction qui doit en fonction d'une define de compilation fait rien ou qqchose genre :
#ifdef DOIT_TRAVAILLER inline void Travail(char * format, ...) { // Tout le toutim } #else inline void Travail(char * format, ...) { } #endif
Ca marche a un detail pret. si DOIT_TRAVAILLER n'est pas définis et que j'appelle
Travail( "%dn", MaFonctionQuiFaitUnCalcul() );
Meme si rien n'est produit a l'ecran, la fonction qui fait le calcul est appelée et travail pour rien. J'aimerais coder une sorte de assert dependant de mon define.
Comme l'a dit Pierre, les parametres de la fonction sont evalues avant l'appel de celle ci (c'est pas vraiment surprenant). Pour eviter l'evaluation, il suffit de ne pas appeler la fonction, puisque de toute facon quand on ne doit pas travailler, la fonction Travail et vide.
Il y a une methode classique qui consiste a placer l'appel de la fonction dans l'alternative d'un if, avec dans le test un drapeau qui evalue a vrai si on ne doit pas appeler la fonction, et faux sinon. En gros, ca ressemble a ca:
Pas en C++, a moins d'accepter les doubles parentheses comme dans:
Travail(("%dn", MaFonctionQuiFaitUnCalcul()));
a+, ld.
Michel Decima
Peut-être qu'une autre macro : #ifdef DOIT_TRAVAILLER inline void Travail(char * format, ...) { // Tout le toutim } #define TRAVAIL(a,b) Travail(a,b) #else inline void Travail(char * format, ...) { } #define TRAVAIL(a,b) #endif
La fonction Travail a un nombre de parametres variable (cf le ...), mais la macro TRAVAIL n'a que 2 parametres. Si on veut continuer a offrir le nombre variable de parametres, il faut soit definir autant de macros que necessaire, mais on ne peut pas utiliser le meme nom, soit definir une macros avec un nombre variable de parametres, mais ca doit pas etre conforme en C++ (c'est seulement en C, corrigez moi sinon).
Peut-être qu'une autre macro :
#ifdef DOIT_TRAVAILLER
inline void Travail(char * format, ...)
{
// Tout le toutim
}
#define TRAVAIL(a,b) Travail(a,b)
#else
inline void Travail(char * format, ...)
{
}
#define TRAVAIL(a,b)
#endif
La fonction Travail a un nombre de parametres variable (cf le ...), mais
la macro TRAVAIL n'a que 2 parametres. Si on veut continuer a offrir le
nombre variable de parametres, il faut soit definir autant de macros que
necessaire, mais on ne peut pas utiliser le meme nom, soit definir une
macros avec un nombre variable de parametres, mais ca doit pas etre
conforme en C++ (c'est seulement en C, corrigez moi sinon).
Peut-être qu'une autre macro : #ifdef DOIT_TRAVAILLER inline void Travail(char * format, ...) { // Tout le toutim } #define TRAVAIL(a,b) Travail(a,b) #else inline void Travail(char * format, ...) { } #define TRAVAIL(a,b) #endif
La fonction Travail a un nombre de parametres variable (cf le ...), mais la macro TRAVAIL n'a que 2 parametres. Si on veut continuer a offrir le nombre variable de parametres, il faut soit definir autant de macros que necessaire, mais on ne peut pas utiliser le meme nom, soit definir une macros avec un nombre variable de parametres, mais ca doit pas etre conforme en C++ (c'est seulement en C, corrigez moi sinon).
Michel Decima
Dominique Vaufreydaz wrote:
Bonjour,
C'est normal, les paramètres de la fonction sont évalués avant qu'elle ne soit appelée
Eh ouai, c'est d'ailleurs mieux ainsi ;-P
La seule solution que je connaisse consiste à mettre la directive de compilation au niveau supérieur:
Pas en C++, a moins d'accepter les doubles parentheses comme dans:
Travail(("%dn", MaFonctionQuiFaitUnCalcul()));
Les doubles parentheses, c'est pour une macro qui prends un parametre. Mais si la macro n'a pas de parametres (cf mon autre post), on peut s'en passer (a moins que ca ne soit pas du C++, mais pourtant j'y croyais...)
Dominique Vaufreydaz wrote:
Bonjour,
C'est normal, les paramètres de la fonction sont évalués avant qu'elle
ne soit appelée
Eh ouai, c'est d'ailleurs mieux ainsi ;-P
La seule solution que je connaisse consiste à mettre la directive de
compilation au niveau supérieur:
Pas en C++, a moins d'accepter les doubles parentheses comme dans:
Travail(("%dn", MaFonctionQuiFaitUnCalcul()));
Les doubles parentheses, c'est pour une macro qui prends un parametre.
Mais si la macro n'a pas de parametres (cf mon autre post), on peut
s'en passer (a moins que ca ne soit pas du C++, mais pourtant j'y
croyais...)
Pas en C++, a moins d'accepter les doubles parentheses comme dans:
Travail(("%dn", MaFonctionQuiFaitUnCalcul()));
Les doubles parentheses, c'est pour une macro qui prends un parametre. Mais si la macro n'a pas de parametres (cf mon autre post), on peut s'en passer (a moins que ca ne soit pas du C++, mais pourtant j'y croyais...)
Laurent Deniau
Michel Decima wrote:
Dominique Vaufreydaz wrote:
Bonjour,
C'est normal, les paramètres de la fonction sont évalués avant qu'elle ne soit appelée
Eh ouai, c'est d'ailleurs mieux ainsi ;-P
La seule solution que je connaisse consiste à mettre la directive de compilation au niveau supérieur:
