C4127: L'expression conditionnelle est constante

Le code suivant génère un avertissement C4127 (expression conditionnelle est constant) dans Visual Studio 2010 (où alias_wchar_t est un alias pour wchar_t):

if (sizeof(alias_wchar_t) == sizeof(wchar_t)) //warning occurs here
{
    //do stuff
}
else
{
    //do other stuff
}

Ce qui est la façon la plus élégante pour résoudre ce problème, bref de suppression de l'avertissement?

La meilleure solution que j'ai trouvé est de farcir le conditionnel en static bool, et de l'utiliser comme condition. Il y a une bonne quantité de code ci-dessus et en dessous de la si-sinon, j'ai donc envelopper le tout dans des accolades pour limiter la portée de la variable autant que possible:

//<snip>

{
    static bool isSameSize = (sizeof(alias_wchar_t) == sizeof(wchar_t));
    if (isSameSize)
    {
        //do stuff
    }
    else
    {
        //do other stuff
    }
}

//<snip>

Ce qui se sent assez brut. Cela semble comme il devrait être résolu au moment de la compilation plutôt que de l'exécution, mais le préprocesseur ne sais pas à propos de sizeof. Est-il plus propre, plus élégante façon de résoudre ce problème?

source d'informationauteur Christopher Berman

  1. 7

    Il semble que vous savez ce qui se passe, et vous êtes très bien avec ce.

    Compilateur pragmas sont destinés à des cas comme celui-ci:

    __pragma(warning(push))
__pragma(warning(disable:4127))
if (sizeof(alias_wchar_t) == sizeof(wchar_t)) {
__pragma(warning(pop))
}

    Essentiellement, vous indiquez le compilateur (et plus important encore, pour les lecteurs de votre code) que vous avez pris connaissance de l'avertissement, et que vous savez ce que vous faites.

  2. 5

    Ce qui est la façon la plus élégante pour résoudre ce problème, bref de la suppression de la
    avertissement?

    La condition est connue au moment de la compilation, de sorte que vous pouvez faire le chèque au moment de la compilation, trop. Ne pas utiliser un ifil suffit de laisser le compilateur insérer un appel à la bonne fonction. Voici un exemple complet:

    #include <iostream>

typedef short alias_wchar_t; //for testing

template<bool Condition>
struct DoStuff
{
};

template<>
struct DoStuff<true>
{
    static void doStuff()
    {
        std::cout << "sizeof(alias_wchar_t) == sizeof(wchar_t)\n"; 
    }
};

template<>
struct DoStuff<false>
{
    static void doStuff()
    {
        std::cout << "sizeof(alias_wchar_t) != sizeof(wchar_t)\n"; 
    }
};

void doStuff()
{
    DoStuff<sizeof(alias_wchar_t) == sizeof(wchar_t)>::doStuff();
}

int main()
{
    doStuff();
}

    Si c'est vraiment plus élégante que votre code d'origine (avec juste ce message d'avertissement du compilateur est désactivé pour cette unité de compilation) est opinion, je dirais.

    Dans tous les cas, cette compile avec pas d'avertissements à /W4 CR 2013.

  3. 3

    Une autre façon de désactiver l'avertissement est de créer une fausse identité de la fonction et de l'utiliser sur l'une des constantes.

    //Define this somewhere
template<typename T> const T& identity(const T& t) { return t; }

...

//NB: 'identity' used only to remove "warning C4127"
if (identity(sizeof(alias_wchar_t)) == sizeof(wchar_t))
{
    //do stuff
}
else
{
    //do other stuff
}

    Ce n'est pas parfait, mais semble plus léger que les autres solutions et réutilisables pour les différents type de constantes.

  4. 2

    C'est ce que je suis venu avec. Il ne cause pas de mises en garde dans Microsoft Visual Studio 2013 et il ne nécessite pas que vous utilisez Visual C++ spécifiques Pragmas.

    D'abord définir le modèle suivant de la classe.

    template <bool b>
struct condition
{
    static bool test()
    {
        return true;
    }
};
template <>
struct condition<false>
{
    static bool test()
    {
        return false;
    }
};

    De l'utiliser ensuite comme suit.

    if (condition<sizeof(alias_wchar_t) == sizeof(wchar_t)>::test())

    J'ai eu l'idée de le C++14 std::conditionnel décrit à http://en.cppreference.com/w/cpp/types/conditional.

  5. 1

    Si c'est juste une expression constante alors utiliser:

    typedef wchar_t alias_wchar_t;
bool constExpression = sizeof(alias_wchar_t) == sizeof(wchar_t);
if (constExpression) //potential warning
{
    //do stuff
}
else
{
    //do other stuff
}

    Il semble que le c4127 est généré par la seule action de l'évaluation d'une expression constante dans le contrôle de la déclaration.