Fixing „Vergleich ist immer falsch ...“ Warnung in GCC

Question

ich ein Problem habe, die ich bin sicher, einfach zu beheben, aber ich bin ratlos ...

ich eine Vorlage haben, die (immer falsch ist aufgrund der begrenzten Reichweite von DatentypVergleich), wenn dieser Code kompiliert wird für einen Typ ohne Vorzeichen

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

Nun denn offensichtlichen Gründen ist GCC mir eine Warnung zu geben: führt den folgenden Code ein. Ich verstehe voll und ganz die Gründe dafür und ich habe die numeric_limits-Prüfung durchgeführt, um zu sehen, ob ich den Compiler dazu bringen könnte, den Mund zu halten (es funktionierte für MSVC). Ach, unter GCC bekomme ich die Warnung. Gibt es eine Möglichkeit, diese Warnung zu beheben (kurz vor dem Deaktivieren der Warnung, die ich nicht einmal weiß, wenn Sie mit GCC tun können)? Der Code wird sowieso nie aufgerufen und ich nehme an, der Optimierer wird es auch kompilieren, aber ich werde die Warnung nicht los.

Kann mir jemand eine Lösung geben?

Prost!

Answer 1

Einfachere Lösung:

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

Kann mir jemand eine Lösung geben?

Nichts revolutionär, aber ich mache das normalerweise durch Überladung. Etwas in diese Richtung:

//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>()); 
} 

Wenn Sie Klassen-Templates anstelle von Funktionsschablonen verwenden können, können Sie Spezialisierung statt Überlastung verwenden. (Es gibt keine Funktion Schablonen-Teil Spezialisierung, die Funktion ein bisschen mehr einen Streit Vorlagen spezialisiert macht.)

Answer 3

Sie Ihre Funktion wie diese spezialisieren können:

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>(); 

einfach die Warnung zu deaktivieren könnte allerdings besser sein.

Answer 4

Siehe https://stackoverflow.com/a/8658004/274937 für die reale Lösung, die -Wtype-Grenzen Warnungen von Fall zu Fall erlaubt es unterdrückt wird. Kurz gesagt, wickeln Sie einfach jeden Vergleich, der die Warnung generiert, in eine Dummy-Funktion.