फिक्सिंग "तुलना हमेशा गलत है ..." जीसीसी

Question

में चेतावनी मैं एक समस्या जो मुझे यकीन है कि ठीक करने के लिए सरल है, लेकिन मैं एक नुकसान में हूँ हूँ ...

आ रही है मैं एक टेम्पलेट है निम्नलिखित कोड करता है:

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

अब के लिए, स्पष्ट कारणों, जीसीसी मुझे एक चेतावनी दे रहा है जब इस कोड को एक अहस्ताक्षरित प्रकार के लिए संकलित किया गया है (तुलना हमेशा डेटा प्रकार की सीमित रेंज की वजह से गलत है)। मैं इसके पीछे तर्क को पूरी तरह से समझता हूं और मैंने संख्यात्मक_लिमिट्स चेक में यह देखने के लिए जांच की है कि क्या मैं इसके बारे में बंद करने के लिए कंपाइलर प्राप्त कर सकता हूं (यह एमएसवीसी के लिए काम करता है)। जीसीसी के तहत मुझे चेतावनी मिलती है। क्या इस चेतावनी को ठीक करने के लिए कोई तरीका है (चेतावनी को अक्षम करने से कम जिसे मैं यह भी नहीं जानता कि आप जीसीसी के साथ क्या कर सकते हैं)? कोड को वैसे भी कभी नहीं बुलाया जाएगा और मुझे लगता है कि ऑप्टिमाइज़र इसे भी संकलित करेगा लेकिन मैं चेतावनी से छुटकारा नहीं पा सकता हूं।

क्या कोई मुझे इसका समाधान दे सकता है?

चीयर्स!

Answer 1

सरल समाधान:

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

क्या कोई मुझे इसका समाधान दे सकता है?

कुछ भी क्रांतिकारी नहीं है, लेकिन मैं आमतौर पर ओवरलोडिंग द्वारा ऐसा करता हूं। उन पंक्तियों के साथ कुछ:

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

आप समारोह टेम्पलेट्स के बजाय वर्ग टेम्पलेट का उपयोग कर सकते हैं, तो आप विशेषज्ञता के बजाय अधिक भार का उपयोग कर सकते हैं। (कोई समारोह टेम्पलेट आंशिक विशेषज्ञता, बनाता है जो समारोह विशेषज्ञता एक परेशानी का एक सा अधिक टेम्पलेट्स है।)

Answer 3

आप इस तरह अपने कार्य के विशेषज्ञ कर सकते हैं:

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

बस चेतावनी को अक्षम करने हालांकि बेहतर हो सकता है।

Answer 4

वास्तविक समाधान है, जो दबा -Wtype सीमा की अनुमति देता है के लिए https://stackoverflow.com/a/8658004/274937 देखें चेतावनी मामला-दर-मामला। संक्षेप में, बस प्रत्येक तुलना को लपेटें, जो चेतावनी उत्पन्न करता है, एक डमी फ़ंक्शन में।