Valeur constante dans l'expression conditionnelle

Question

Dans un coding style question about infinite loops, certaines personnes ont mentionné qu'elles préféraient le style for (;;) car le style while (true) donnait des messages d'avertissement sur MSVC à propos d'une expression conditionnelle constante. Cela m'a beaucoup surpris, car l'utilisation de valeurs constantes dans les expressions conditionnelles est un moyen utile d'éviter #ifdef l'enfer. Par exemple, vous pouvez avoir dans votre tête:

#ifdef CONFIG_FOO 
extern int foo_enabled; 
#else 
#define foo_enabled 0 
#endif 

Et le code peut simplement utiliser un conditionnel et faire confiance au compilateur de elide le code mort quand CONFIG_FOO n'est pas défini:

if (foo_enabled) { 
    ... 
} 

Au lieu de avoir à tester CONFIG_FOO chaque fois foo_enabled est utilisé:

#ifdef CONFIG_FOO 
if (foo_enabled) { 
    ... 
} 
#endif 

Ce modèle de conception est utilisé tout le temps dans le noyau Linux (par exemple, include/linux/cpumask.h définit plusieurs AMRC os à 1 ou 0 lorsque SMP est désactivé et à un appel de fonction lorsque SMP est activé).

Quelle est la raison de cet avertissement MSVC? De plus, existe-t-il un meilleur moyen d'éviter l'enfer #ifdef sans avoir à désactiver cet avertissement? Ou est-ce un avertissement trop large qui ne devrait pas être activé en général?

Answer 1

Un avertissement ne signifie pas automatiquement que le code est mauvais, juste suspicieux.

Personnellement, je commence à partir d'une position de permettre tous les avertissements que je peux, puis désactiver tout ce qui s'avère plus ennuyeux qu'utile. Celui qui se déclenche chaque fois que vous lancez quelque chose à un bool est généralement le premier à partir.

Answer 2

je crois qu'il est d'attraper des choses comme

if(x=0) 

lorsque vous vouliez dire

if(x==0) 

Answer 3

Une façon simple d'éviter l'avertissement serait:

#ifdef CONFIG_FOO 
extern int foo_enabled; 
#else 
extern int foo_enabled = 0; 
#endif 

Answer 4

Je pense que la raison l'avertissement est que vous pourriez avoir par inadvertance une expression plus complexe qui évalue à une constante sans s'en rendre compte. Supposons que vous ayez une telle déclaration dans un en-tête:

const int x = 0; 

puis plus tard, loin de la déclaration de x, vous avez une condition comme:

if (x != 0) ... 

Vous pourriez ne pas remarquer que c'est une constante expression.