Discussion :

[elraton]

Bonjour,

j'ai besoin de faire une fonction debug avec plusieurs niveau qui soit activ� en mode debug et qui n'existe pas en mode release.

pour l'instant j'ai le code suivant:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//Level of debug printf
enum {
	DEBUG_LOW,
	DEBUG_MED,
	DEBUG_HIGH,
};
 
int g_level=DEBUG_MED;	//Global variable
 
 
void printf_dbg(int level, const char* szFormat, ...) {
	if(level <= g_level) {
		va_list args;
		va_start(args,szFormat);
		vfprintf(stdout,szFormat,args);
		fflush(stdout);
		va_end(args);
	}
}
 
int funcConsumeCPU(int n) {
	int i, ret=0;
	for(i=0;i<n;i++) {
		ret+=i*i-(i-1)*(i-1);
	}
	return ret;
}
 
 
//Appel a la function
int main(int argc,const char *argv[])
{
	printf_dbg(DEBUG_HIGH,"La function qui consume bcp de CPU retourne %d",funcConsumeCPU(100000));
	return 1;
}

Mais si il n'y aura rien d'imprimer je devrais quand meme entrer dans funcConsumeCPU() et perdre beaucoup de temps.
On pourrait donc utiliser un #define pour eviter de rentrer dans cette function en mode release.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
#ifdef DEBUG
#define   PRINTF_DBG(a,b,c) printf_dbg(a,b,c)
#else
#define  PRINTF_DBG(a,b,c)
#endif

Le gros probl�me du #define c'est que le nombre d'argument n'est pas variable. Je voudrais donc savoir comment utiliser un nombre argument variable pour les #define?

ou dois-je faire un truc genre?

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
PRINTF_DBG(a,b)  printf_dbg(a,b)
PRINTF_DBG(a,b,c)  printf_dbg(a,b,c)
PRINTF_DBG(a,b,c,d)  printf_dbg(a,b,c,d)
PRINTF_DBG(a,b,c,d,e)  printf_dbg(a,b,c,d,e)
PRINTF_DBG(a,b,c,d,e,f)  printf_dbg(a,b,c,d,e,f)
...

[coyotte507]

Salut,

comme �a �a devrait marcher:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <iostream>
 
using namespace std;
 
void printf_dbg(int i, int j)
{
    ;
}
 
int fonction ()
{
    cout << "fonction appelée" << endl;
    return 0;
}
 
#define PRINTF_DBG printf_dbg
#define PRINTF_DBG2(...)
 
 
int main()
{
    PRINTF_DBG(fonction(), 0);
    PRINTF_DBG2(fonction(), 0);
 
    return 0;
}

Donc de ce style l�:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
#ifdef DEBUG
#define   PRINTF_DBG printf_dbg
#else
#define  PRINTF_DBG(...)
#endif

[elraton]

merci, exactement ce que je cherchais

[coyotte507]

D�sol� de relancer le sujet,

mais voici une solution plus propre au niveau C++ (car ne faisant pas appel aux macros "..." du C99) et qui marche sous visual:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
#ifdef DEBUG
#define   PRINTF_DBG printf_dbg
#else
/* le (void) est là pour enlever le warning qui n'a pas lieu d'être */
#define  PRINTF_DBG if (0) (void)
#endif

Comme �a ton code sera unreachable...

[nicroman]

Par d�finition, tu ne veux pas avoir de "logging" qu'en mode debug... Si tu es en mode debug, tu as le debugger.
Par contre, le logging est hyper important en mode "release"... Donc c'est � mon avis une mauvaise conception de desactiver le logging en release.

Tu peux aussi faire:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 
enum LogLevel {
    Trace = 0,
    Debug,
    Warn,
    Info,
    Error
};
 
extern LogLevel  g_logLevel;
 
void Log(const char*, ...);
void Log(const wchar_t*, ...);
 
#define   LOG(lvl,...)      if (lvl > g_logLevel) Log(lvl,__VA_ARGS__)
 
#define   DEBUG(...)      LOG(LogLevel.Debug,__VA_ARGS__)
#define   WARN(...)       LOG(LogLevel.Warn,__VA_ARGS__)
#define   INFO(...)        LOG(LogLevel.Info,__VA_ARGS__)
#define   ERROR(...)      LOG(LogLevel.Error,__VA_ARGS__)

[elraton]

Hum,

merci pour l'id�e je crois que je vais mixer les deux afin de ne pas compiler les DEBUG et TRACE, mais de compiler les ERROR, WARNING, INFOS