std::numeric_limits<T>::is_signed generates warning in function template compiled Release by Steve Huston

Hi,

Thanks for reporting this issue. I've resolved it as By Design because the compiler and Standard Library implementation are working correctly here.

When you instantiate convert<uint32_t>(), the compiler sees a test that will be executed at runtime, followed by unary minus being applied to an unsigned integer. Although it warns that the conditional expression is constant (at /W4), it also warns about the unary minus, despite the fact that that code will never be executed at runtime.

If you want your code to compile cleanly without suppressing warnings, you need to perform this test at compiletime. There are many ways to do so, but the easiest way (which we prefer in the STL's implementation) is "tag dispatch":

C:\Temp>type meow.cpp
#include <stdint.h>
#include <iostream>
#include <type_traits>
using namespace std;

template <typename T> T convert_helper(T t, true_type) {
    return -t;
}

template <typename T> T convert_helper(T t, false_type) {
    return t;
}

template <typename T> T convert() {
    T t = 4;

    return convert_helper(t, is_signed<T>());
}

int main() {
    cout << "convert<int32_t>(): " << convert<int32_t>() << endl;
    cout << "convert<uint32_t>(): " << convert<uint32_t>() << endl;
}

C:\Temp>cl /EHsc /nologo /W4 /MTd meow.cpp
meow.cpp

C:\Temp>meow
convert<int32_t>(): -4
convert<uint32_t>(): 4

What's happening here is that is_signed<T> is a struct template that derives from either a true_type struct or false_type struct (in reality they are typedefs, but thinking of them as plain old structs is correct here). In my example, convert() says is_signed<T>() to construct a temporary object of this type. I could also have said is_signed<T> dummy; followed by return convert_helper(t, dummy); although that would be more verbose. Overload resolution then selects either convert_helper(T, true_type) or convert_helper(T, false_type). (We are passing an object of derived type by value. Doing this "slices" it, but we don't care - we're doing this for overload resolution only, and we don't care about the dummy object itself. convert_helper() doesn't even bother to name this parameter.) The key part is that only the desired overload of convert_helper() is instantiated. For unsigned types, the expression "-t" is never compiled, because that's in an overload that isn't selected.

Note: Connect doesn't notify me about comments. If you have any further questions, please E-mail me.

Stephan T. Lavavej
Senior Developer - Visual C++ Libraries
stl@microsoft.com

Thank you for submitting feedback on Visual Studio and .NET Framework. Your issue has been routed to the appropriate VS development team for investigation. We will contact you if we require any additional information.

Thank you for your feedback, we are currently reviewing the issue you have submitted. If this issue is urgent, please contact support directly(http://support.microsoft.com)