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

[ram-0000]

Au fait, c'est pour quel OS ?

[elraton]

windows et linux (MSVC, MinGW et GCC) pourquoi ?

[ram-0000]

regarde ici, c'est une librairie de log (assez simple) debug et release que j'ai développée et que j'utilise tout le temps avec pas mal de fonctionnalités qui pourraient t'interesser. Tu peux l'utiliser en l'état ou alors tu copie/colle les sources, tu les adaptes et tu intégres dans ton projet

[elraton]

merci ça me parait vraiment bien mais est-ce que tu as tester sous linux ?

[ram-0000]

Non, uniquement sous Windows.

Par contre, si tu regardes le code, tu verras que c'est assez simple donc cela doit pouvoir s'adapter.