Thread: Function template specialization?

When compiling this code on VC++ 6.0 it gives me:

Code:

error C2667: 'StringToNum' : none of 2 overload have a best conversion
error C2668: 'StringToNum' : ambiguous call to overloaded function

Code:

#include <string>
#include <sstream>
#include <stdexcept>
#include <climits>

template <typename E,
          typename T,
          typename A,
          typename N>
void StringToNum( const std::basic_string<E, T, A>&  str,
                                                 N&  num )
{
    std::basic_stringstream<E, T, A> ss( str );

    if ( !(ss >> num) )
    {
        throw std::invalid_argument( "Error converting string to number!" );
    }
}

template <typename E,
          typename T,
          typename A>
void StringToNum( const std::basic_string<E, T, A>&  str,
                                     unsigned char&  num )
{
    std::basic_stringstream<E, T, A> ss( str );
    unsigned short snum = 0;

    if ( !(ss >> snum) || (snum > UCHAR_MAX) )
    {
        throw std::invalid_argument( "Error converting string to number!" );
    }
    num = static_cast<unsigned char>( snum );
}

using namespace std;

int main()
{
    unsigned char num = 0;
    wstring str( L"Hello world" );
    StringToNum( str, num );
    return 0;
}

and on Comeau it's quite a bit more verbose...
What's wrong and how can I make StringToNum() work for unsigned char numbers?

When I tried compiling it without the specialization for unsigned chars I got this error:

Code:

error C2679: binary '>>' : no operator defined which takes a right-hand operand of type 'char' (or there is no acceptable conversion)
        D:\Programming\C++\Test\src\main.cpp(15) : see reference to function template instantiation 'class std::basic_istream<unsigned short,struct std::char_traits<unsigned short> > &__cdecl std::operator >>(class std::basic_istream<unsigned short,
struct std::char_traits<unsigned short> > &,unsigned char &)' being compiled

Originally Posted by Mario F.

What function would the compiler choose if on the following template N was a unsigned char?

Code:

template <typename E,
          typename T,
          typename A,
          typename N>

Since I provided a function that excplicitely takes an unsigned char, shouldn't it choose that one?

Originally Posted by laserlight

I tested cpjust's original code example with the MinGW port of g++ 3.4.5 and MSVC8, and it compiled without even a warning in both cases. However, it ran with an segfault in both cases too.

Try using Comeau. It gives you pages of errors.

Originally Posted by Mario F.

I believe he should do a partial specialization of the first template to take a unsigned char&.

Code:

template <typename E,
          typename T,
          typename A>
void StringToNum<typename E, typename T, typename A, unsigned char&>( const std::basic_string<E, T, A>&  str, unsigned char&  num ) {

That didn't work. This is on VC++ 6.0, so maybe that has something to do with it also...

Originally Posted by laserlight

I tested cpjust's original code example with the MinGW port of g++ 3.4.5 and MSVC8, and it compiled without even a warning in both cases. However, it ran with an segfault in both cases too.

Oh, I think I might know why it crashed. Change the string to "255" instead of "Hello world".

Anyways, I found a workable, but slightly less desirable solution:

Code:

template <typename E,
          typename T,
          typename A,
          typename N>
void StringToNum( const std::basic_string<E, T, A>&  str,
                                                 N&  num )
{
    std::basic_stringstream<E, T, A> ss( str );
    long lnum = 0;

    if ( !(ss >> lnum) || (lnum < std::numeric_limits<N>::min()) || (lnum > std::numeric_limits<N>::max()) )
    {
        throw std::invalid_argument( "Error converting string to number!" );
    }

	num = static_cast<N>( lnum );
}

BTW, I tried using long long int lint = 0; but VC++ 6.0 said I can't say long twice.
I've seen that used in other examples to get 64-bit integers... Is long long standard, or is it a compiler extension?

There probably isn't a basic_stringstream overload for operator>>() for 64-bit ints anyways, so maybe I'd better keep it as a long.

Originally Posted by Elysia

Sure, there is.

Code:

std::stringstream s;
s << (uint64_t)0; // Works
s << (int64_t)0; // Works
uint64_t n;
s >> n; // Works
s >> (int64_t)n; // Doesn't work! :(

At least on Microsoft's compilers.

I think they key phrase there is "At least on Microsoft's compilers".
I tried using a long long with stringstreams on Comeau and it didn't have an operator>>() for long long.