Discussion :

[kacedda]

Bonjour,

Si je fais ca, dans une classe ou en fonction:

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
void fonction(char* chaine)
{
#ifdef DEBUG
cout << chaine;
#endif
}
 
// ou bien dans une classe
void CMaClasse::fonction(char* chaine)
{
#ifdef DEBUG
cout << chaine;
#endif
}
 
// Dans mon code
fonction();
pMaClasse->fonction();

Et que je compile sans definir le DEBUG, en release par exemple. Est-ce que le compilo detecte que la fonction ne fait rien ou pas? Car c'est bien une optimisation de ne pas faire l'appel!

car techniquement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#undef DEBUG
fonction();
// revient a =>
/* du vide */

Alors

PS: je pense que l'on peut compiler en mode asm et regarder si oui ou non on a l'appel, mais je sais pas faire

[Médinoc]

Ça dépend si l'optimiseur est activé et si le contenu de la fonction est visible pendant qu'on compile l'appel.

C'est naturellement le cas pour les fonctions inline, par exemple...

[kacedda]

Oui pour les fonctions inline.

Mais dans le cas ou on a des grosses fonctions, ou tout simplement dont c'est pas tres bien d'inliné, je me demandais.

mais bon ok, donc l'optimiseur detecte les fonctions vides. Merci pour l'info.
Ils sont fort ces compilos

[Médinoc]

Mais il ne la détecte que si il voit son code.
Donc, pas si elle est dans un autre fichier source... (sauf si la Link-Time Code Generation est activée, bien sûr)

[zais_ethael]

A priori, le seul cas où le compilo verrait le code est celui où la fonction est inline (il y a bien les namespaces non nommés et les fonctions statiques du C, mais vous les utilisez dans des headers vous??). Donc tu peux considérer que ça ne fonctionne que si la fonction est inline.

[Médinoc]

Si la fonction est dans le même fichier source, le compilo la connait. Il peut même décider de l'inliner sans que tu lui demandes.

Et en LTCG, le compilo voit toutes les fonctions d'un coup, il peut donc optimiser à fond.

[nicroman]

Pour que ca passe les optimisations de compilation à mort:

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
 
void function_call(const char* str)
{
    cout << str;
}
 
#ifdef DEBUG
inline void function(const char* str) { function_call(str); }
#else
inline void function(const char* str) {}
#endif
 
class CMaClasse
{
#ifdef DEBUG
inline void function(const char* str) { funcation_call(str); }
#else
inline void function(const char* str) {}
#endif
};

Mais je conseille vivement un truc... (sans doute dû à de trop nombreuses et fâcheuses expérience du release-mode): Ne JAMAIS virer le code de trace...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
inline void function(const char* str) { if (debug_enabled) function_call(str); }
 
class CMaClass
{
inline void function(const char* str) { if (debug_enabled) function_call(str); }
};

Avec un moyen de modifier la valeur de debug_enabled facilement... ca t'enlevera à cout sur quelques épines un jour...
Le code ne sera pas plus lent en release, de manière visible en tout cas (si le debug_enabled est partagé, il y a de très fortes chances pour qu'il reste longtemps dans le cache mémoire).