No Matching function call to templated function with const parameters - c++

Question

I have a function that is defined as follows:
template < class T> T doSomething(const T value, const T value2, const T value3)
{
T temp = value;
//Do stuff
return temp ;
}
in my main, I go to call it as follows:
doSomething(12.0, 23.0f, 2.0f);
I get an error saying no matching function for call doSomething(double, float, float).
I tried to used const_cast but it didn't seem to fix the issue. Any help would be appreciated.

Answer 1

It's not about the const, but about that T cannot be both double and float at the same time.
If you have a non-template function, one or more parameter can be promoted (or converted) to the parameter type. With a template function, the compiler will have to start by determining what the template type is supposed to be. Here it cannot decide.

Answer 2

Your function definition uses same type "T" for every of three arguments.
C++ is not able to deduct types in cases like this.
Please choose way to fix:
Different types for every argument
template<typename A, typename B, typename C>
A doSomething(const A& value, const B& value2, const C& value3)
{
A temp = value;
//Do stuff
return temp ;
}
Explicit template argument on call:
doSomething<int>(12.0, 23.0f, 2.0f);
Explicit type cast for argument on call:
doSomething(12.0, static_cast<double>(23.0f), static_cast<double>(2.0f));

Answer 3

When using a templated function, you need to supply the template parameters within angle brackets.
I.e. you need to use doSomething<float>(12.0, 23.0f, 2.0f);
Or, at least, if you don't, the compiler has to guess what T is, which means when it sees a double for the first argument it assumes you mean doSomething<double>()

Answer 4

When you call like this:
doSomething(12.0, 23.0f, 2.0f);
then you basically let the compiler to deduce the template argument T, from the function arguments. But in the above call, type of all arguments are not same : the first argument12.0 is double, while the rest two arguments are float (Note that f in 2.0f makes it a float, while 2.0 is a double.). Hence the problem, as the compiler is trying to find a function which accepts double, float, float as arguments. But there is no such function. And the function template cannot be deduced from the arguments, because T has to be same for all arguments.
So the solution is, let T be deduced as either double or float:
doSomething(12.0f, 23.0f, 2.0f); //all are float now
Or this:
doSomething(12.0, 23.0, 2.0); //all are double now
In the first case, T is deduced as float, and in the second case, T is deduced as double.
Alternately, you may choose not to depend on template argument deduction, by providing template argument as:
doSomething<float>(12.0, 23.0f, 2.0f);
Or this:
doSomething<double>(12.0, 23.0f, 2.0f);
Here, in the first case, the 1st argument converts into float, and in the second case, 2nd and 3rd argument convert into double.