de fixation « comparaison est toujours fausse ... » avertissement dans GCC

Question

Je vais avoir un problème dont je suis sûr est simple à corriger, mais je suis à une perte ...

J'ai un modèle exécute le code suivant:

T value  = d; 
if (std::numeric_limits<T>::is_signed) 
{ 
    if (value < 0) 
    { 
     *this += _T("-"); 
     value = -(signed)value; 
    } 
} 

maintenant, pour des raisons évidentes, GCC me donne un avertissement (comparaison est toujours fausse en raison de gamme limitée de type de données) lorsque ce code est compilé pour un type non signé. Je comprends parfaitement le raisonnement derrière cela et j'ai mis dans la vérification numeric_limits pour voir si je pourrais obtenir le compilateur pour se taire à ce sujet (cela a fonctionné pour MSVC). Hélas sous GCC, je reçois l'avertissement. Y at-il un moyen (à moins de désactiver l'avertissement que je ne sais même pas si vous pouvez faire avec GCC) pour corriger cet avertissement? Le code ne sera jamais appelé de toute façon et je suppose que l'optimiseur le compilera également, mais je ne peux pas me débarrasser de l'avertissement.

Quelqu'un peut-il me donner une solution à cela?

À la votre!

Answer 1

solution plus simple:

template <typename T> inline bool isNegative(T value) { 
    return std::numeric_limits<T>::is_signed && value < 0; // Doesn't trigger warning. 
} 

T value  = d; 
if (isNegative(value)) // Doesn't trigger warning either. 
{ 
    *this += _T("-"); 
    value = -1 * value; 
} 

Answer 2

Quelqu'un peut-il me donner une solution à cela?

Rien de révolutionnaire, mais je le fais habituellement en surchargeant. Quelque chose le long de ces lignes:

//Beware, brain-compiled code ahead! 
template< bool B > 
struct Bool { const static bool result = B; } 

template< typename T > 
void do_it(T& , Bool<false> /*is_signed*/) 
{ 
    // nothing to do for unsigned types 
} 

template< typename T > 
void do_it(T& value, Bool<true> /*is_signed*/) 
{ 
    if (value < 0) { 
     *this += _T("-"); 
     value = -(signed)value; 
    } 
} 

template< typename T > 
void do_something(T& value) 
{ 
    do_it(value, Bool<std::numeric_limits<T>::is_signed>()); 
} 

Si vous pouvez utiliser des modèles de classe au lieu de modèles de fonction, vous pouvez utiliser la spécialisation au lieu de surcharge. (Il n'y a pas de modèle de fonction spécialisation partielle, ce qui rend spécialisée fonction des modèles un peu plus embêtant.)

Answer 3

Vous pouvez spécialisez votre fonction comme ceci:

template <bool S> 
void manipulate_sign(T&) {} 

template <> 
void manipulate_sign<true>(T& value) { 
    if (value < 0) 
    { 
    *this += _T("-"); 
    value = -(signed)value; 
    } 
} 

//then call like this: 
manipulate_sign<std::numeric_limits<T>::is_signed>(); 

Juste désactiver l'avertissement pourrait être mieux si.

Answer 4

Voir https://stackoverflow.com/a/8658004/274937 pour la vraie solution, ce qui permet la suppression de -wtype_avertissement limites avertissements au cas par cas. En bref, enroulez chaque comparaison, qui génère l'avertissement, dans une fonction fictive.