How Template Argument Deduction Works

Template argument deduction is the process by which the compiler determines the template arguments based on the types of the function arguments. Here's how it works:

1. The compiler compares the types of the function arguments with the types of the function parameters in the template.
2. If the types match exactly, the corresponding template argument is deduced.
3. If the function argument is a reference or pointer, the compiler will try to deduce the template argument based on the referred or pointed-to type.
4. If the function argument is a const or volatile qualifier, the compiler will attempt to deduce the template argument by removing the qualifiers.
5. If the template has default arguments, they will be used if no corresponding function argument is provided.
6. If the compiler cannot deduce all template arguments or if there are conflicts, a compilation error occurs.

Example:

1template <typename T>
2void foo(T a, T b) {
3// ...
4}
5
6int main() {
7  int x = 10;
8  double y = 5.5;
9  foo(x, x);// T is deduced as int
10  foo(y, 2.3);// T is deduced as double
11  
12  // Compilation error - cannot deduce T
13  // because the arguments have different types
14  foo(x, y);
15}

We can fix this by providing our template arguments, or casting our function arguments to help the compiler deduce how to instantiate the template:

1foo<int, int>(x, y);
2foo(int(x), int(y));