Thread: Help with template class

I wonder how to solve a problem that I have with a template function. The function definition looks like

Code:

template<typename T>
T foo(T a, T b)
{
    return a + b;
}

but this produces an error when I'm trying to compile a program with the code

Code:

foo(0, 0.5)

The error message reads

Code:

error: no matching function for call to 'foo(int, double)'

I tried to fix this by adding two more functions, so I had

Code:

template<typename T>
T foo(T a, T b)
{
    return a + b;
}

template<typename T>
T foo(int a, T b)
{
    return foo(T(a), b);
}

template<typename T>
T foo(T a, int b)
{
    return foo(a, T(b));
}

which solved the first compile error, but then the line

Code:

foo(0, 0)

would not compile, giving me the message

Code:

error: call of overloaded 'foo(int, int)' is ambiguous
candidates are: T foo(T, T) [with T = int]
note:                 T foo(int, T) [with T = int]
note:                 T foo(T, int) [with T = int]

So, I'm looking for a way to make both foo(0, 0.5) and foo(0, 0) compile. Any ideas? Thanks in advance.

Originally Posted by laserlight

Why not just call it as foo(0.0, 0.5)?

Simply because it's simpler to write foo(0, 0.5) :P If I define foo as

Code:

double foo(double a, double b)
{
    return a + b;
}

then foo(0, 0.5) compiles, so I want it to compile even for my more general template function.

Originally Posted by laserlight

If you do want to have two different types involved, then what do you want the return type to be?

If I have an integer type and a float type, I want the integer value to be converted to the float value. If both are float types but of different float types, I want the one with the lowest accuracy to be converted to the type with the higher accuracy.

Actually, I don't want integer types at all, since originally, foo was a function that returned uniformly distributed random numbers (I just simplified it a bit before I started this thread). Hence, I check the type of the number using

Code:

STATIC_ASSERT(!std::numeric_limits<T>::is_integer);

which will give a compile time error if T is an integer type but not if it isn't.

I also have a separate function with a different name especially for integer arguments.

O_o

Outside of specific situations it is better to do what laserlight suggested.

However...

Are you trying to do this for native types only?

Are you trying to do this generally (any type)?

Type discovery, which you'd need to know which type for the function to return, is only partially solved in C++98.

C++11 can do the real thing in a couple of different ways.

*shrug*

In any event, you can always be explicit, by simply picking a type, where you are unaware of the parameter types.

Code:

foo<double>(0, 0.5)

Soma

Okay, thanks for the answer. I think I will just define the function explicitly for all types I am going to use it for, since it rather small, and skip the template.

Originally Posted by phantomotap

C++11 can do the real thing in a couple of different ways.

decltype ? Or were you referring to something else ?

Originally Posted by then

Okay, thanks for the answer. I think I will just define the function explicitly for all types I am going to use it for, since it rather small, and skip the template.

I guess that's fine but you're basically designing a function around a typing convenience. I don't know if this is the first time you've heard this, but C++ is a type strict language and it is best to type what you mean. A parameter list of two doubles means you should pass in two doubles. It's just a decimal point man.