Giới hạn C++ của mẫu không dấu int thông qua mẫu

Question

Tôi đang sử dụng mẫu để chuyển đổi các loại tích phân thành một chuỗi biểu diễn các giá trị nhị phân của chúng. Tôi sử dụng như sau:

template<typename T> 
std::string ToBinary(const T& value) 
{ 
    const std::bitset<std::numeric_limits<T>::digits + 1> bs(value); 
    const std::string s(bs.to_string()); 

    return s; 
} 

Nó hoạt động cho int nhưng không biên dịch với unsigned int:

unsigned int buffer_u[10]; 
int buffer_i[10]; 
... 
ToBinary(buffer_i[1]); //compile and works 
ToBinary(buffer_u[1]); //doesn't compile -- ambiguous overload 

Ông có thể giải thích tại sao?

EDIT:

Vâng, tôi đang sử dụng VS2010

Answer 1

Không gọi ToBinary của bạn là mơ hồ, nó gọi constructor của bitset với một giá trị unsigned. Thật không may đây là một VC++ Bug: http://connect.microsoft.com/VisualStudio/feedback/details/532897/problems-constructing-a-bitset-from-an-unsigned-long-in-the-vc-rc

Edit - Cách giải quyết:

template<> 
std::string ToBinary<unsigned int>(const unsigned int& value) 
{ 
    const std::bitset<std::numeric_limits<unsigned int>::digits> bs(static_cast<unsigned long long>(value)); 
    return bs.to_string(); 
} 

Answer 2

Bạn đang sử dụng VC10? Đã có một vấn đề báo cáo: Microsoft connect. Ngoài ra tôi đoán rằng bạn có thể sửa chữa nó bằng cách đúc kiểu int nếu nó là 32 bit, như thế này:

string s = ToBinary(*reinterpret_cast<int*>(&buffer_u[1])); 

này có thể được thực hiện bên trong của phương pháp là tốt nếu cần thiết. Kết quả của việc diễn giải lại không nên được sử dụng cho arithmetics nữa, mặc dù. ;)

Hoạt động tốt như cách giải quyết đối với tôi (nhưng trông khá xấu xí)

template<typename T> 
std::string ToBinary(const T& value) 
{ 
    switch (sizeof(T)) 
    { 
    case 8: 
     return std::bitset<std::numeric_limits<T>::digits + 1>(*reinterpret_cast<const long*>(&value)).to_string(); 
    case 4: 
     return std::bitset<std::numeric_limits<T>::digits + 1>(*reinterpret_cast<const int*>(&value)).to_string(); 
    case 2: 
     return std::bitset<std::numeric_limits<T>::digits + 1>(*reinterpret_cast<const short*>(&value)).to_string(); 
    case 1: 
     return std::bitset<std::numeric_limits<T>::digits + 1>(*reinterpret_cast<const char*>(&value)).to_string(); 
    } 
    return "n/a"; 
} 

Answer 3

Nếu bạn nhìn vào các tiêu chuẩn (FDI n3290), sau đó bạn thấy rằng std::bitset có nhiều nhà xây dựng:

Đầu tiên có một điều này:

20.5.1 constructors bitset [bitset.cons]

constexpr bitset(unsigned long long val) noexcept;

Effects: Tạo thời đối tượng của lớp bitset, khởi tạo vị trí M bit đầu tiên để các giá trị bit tương ứng trong val. M là nhỏ hơn của N và số bit trong biểu diễn giá trị (3.9) không có dấu dài. Nếu M < N, các vị trí bit còn lại là được khởi tạo về 0.

Sau đó, cũng là một trong những này, mà tôi nghi ngờ có thể là có thể gây ra những thứ để trở thành ambigious, khi bạn gọi nó với unsigned int

template <class charT> 
explicit bitset(
const charT* str, 
typename basic_string<charT>::size_type n = basic_string<charT>::npos, 
charT zero = charT(’0’), charT one = charT(’1’)); 

Effects: Tạo thời đối tượng của lớp bitset như thể by

bitset(n == basic_string<charT>::npos ? basic_string<charT>(str) : 
basic_string<charT>(str, n), 0, n, zero, one)