Function Templates

A function template is a family of functions. In this post, I want to dive deeper into function templates.

Here is a short reminder to get you on the same page.

When you instantiate a function template such as max for int and double

template <typename T>
T max(T lhs,T rhs) {
    return (lhs > rhs)? lhs : rhs;
}

int main() {
  
    max(10, 5);
    max(10.5, 5.5);
  
}

the compiler generates a fully specialized function template for int and double: max<int> and max<double>. The generic part is in both cases empty: template<> Thanks to C++ Insights, here are the insights.

Okay, now I can dive into the details. What happens, when function templates and non-template functions (in short functions) overload?

Overloading of Function Templates and Functions

Let me use the function max once more. This time I instantiate it for float and double, and I provide a function max taking also doubles.

Here is my next example:

template <typename T>
T max(T lhs,T rhs) {
    return (lhs > rhs)? lhs : rhs;
}

double max(double lhs, double rhs) {
    return (lhs > rhs)? lhs : rhs;
}

int main() {
  
    max(10.5f, 5.5f); // (1)
    max(10.5, 5.5);   // (2)
  
}

 You may guess my question. What happens in lines (1) and (2)? Here are a few questions?

• Line (1): Does the compiler choose the function template or the function and promote the float to double.
• Line (2): Either the function and the function templates are ideal fits. This seems to be ambiguous and may cause a compiler error.

The answer to questions is pretty intuitive and follows the general rule in C++. The compiler chooses the best fitting function.

• Line (1): The function template is the better fit because the function would require a promotion from float to double.
• Line (2): The function template and the function are ideal fits. In this case, an additional rule kicks in. When both are equally good fits, the compiler prefers the function.

As before, C++ Insights helps to visualize this process.

The screenshot shows it explicitly. Only the use of the function template max with float (line 2) triggers the instantiations of the function template.

Let's go further in our journey through the basics of function templates.

First disclaimer: I ignore concepts in this post.

Different Template Arguments

Let me use my function template max with two values having different types.

template <typename T>
T max(T lhs,T rhs) {
    return (lhs > rhs)? lhs : rhs;
}

int main() {
  
    max(10.5f, 5.5);
  
}

 Let's try it out on C++ Insights:

 Wow! What is happening here? Why is the float not promoted to a double? Honestly, the compiler thinks differently, and let me explain how.

• The compiler deduces the template argument from the function argument if possible. In this case, it's possible.
• The compiler does this process of template argument deduction for each function argument.
• For 10.5f the compiler deduces float for T, for 5.5 the compiler deduces double for T.
• Of course, T cannot be float and double at the same time. Because of this ambiguity, the compilation failed.

Second disclaimer: I simplified the process of template argument deduction. I will write an additional post about template argument deduction for function templates and class templates in a future post.

Of course, we want to compare values of different types.

Two Type Parameters

The solution seems to be straightforward. I just introduce a second type parameter.

template <typename T, typename T2>
??? max(T lhs,T2 rhs) {
    return (lhs > rhs)? lhs : rhs;
}

int main() {
  
    max(10.5f, 5.5);
  
}

This is easy! Right? But there is a serious problem. Do you see the three question marks as return type? This problem typically occurs when your function template has more than one type parameter. What should be the return type?.

In this concrete case, should the return type be T, T2, or a Type R derived from T and T2? This was a challenging task before C++11, but it is quite easy with C++11.

Here are a few solutions I have in mind:

// automaticReturnTypeDeduction.cpp

#include <type_traits>

template <typename T1, typename T2>      // (1)
typename std::conditional<(sizeof(T1) > sizeof(T2)), T1, T2>::type max1(T1 lhs,T2 rhs) {
    return (lhs > rhs)? lhs : rhs;
}

template <typename T1, typename T2>      // (2)
typename std::common_type<T1, T2>::type max2(T1 lhs,T2 rhs) {
    return (lhs > rhs)? lhs : rhs;
}

template <typename T1, typename T2>     // (3)
auto max3(T1 lhs,T2 rhs) {
    return (lhs > rhs)? lhs : rhs;
}

int main() {
  
    max1(10.5f, 5.5);                  
    max2(10.5f, 5.5);                  
    max3(10.5f, 5.5);                  
  
}

 The first two versions max1 (line 1) and max2 (line 2) are based on the type-traits library. The third version max3 (line 3) uses the automatic type deduction of auto.

• max1 (line 1): typename std::conditional<(sizeof(T1) > sizeof(T2)), T1, T2>::type returns the type T1, or T2 that is bigger. std::conditional is a kind of compile-time ternary operator.
• max2 (line2): typename td::common_type<T1, T2>::type returns the common type of the types T1 and T2. std::common_type can accept an arbitrary number of arguments.
• max3 (line3): auto should be self-explanatory.

• max1(line 1): You can only guess the return type. In the return statement, the smaller type (float) is converted to double.
• max2(line 2): As for max1, the return statement gives an idea about the return type: the float value is converted to double.

• max3 (line 3): Now, we can see the return type explicitly. It is a double.

What's next?

In this installment, I solved the challenge of different types of function arguments by using more than one type parameter. Next time, I take a different approach and explicitly specify the template arguments.