catalogue
3.1 function template definition form
4. Function template and function overloading
4.1 function templates cannot convert implicit data types
4.3 if the function template will produce a better match, use the function template
4.3 function templates and ordinary functions together, and call rules
5. Function template calling mechanism
1. Preface
C + + provides the concept of template programming. The so-called template is actually to establish a general function or class. The type inside the class and the formal parameter type of the function are not specified specifically, but are represented by a virtual type. This common approach is called template. Templates are the foundation of generic programming, which is writing code in a way independent of any particular type.
2. Why use function templates
To implement the comparison function for int, char and flaot, we can:
int Max(int a, int b) { return a > b ? a : b; } char Max(char a, char b) { return a > b ? a : b; } float Max(float a, float b) { return a > b ? a : b; }
In fact, these three functions can be completed with one function template:
//The template keyword tells the C + + compiler that I want to start generic programming. Please don't report errors at will //T - parameterized data type template <typename T> T Max(T a, T b) { return a > b ? a : b; }
When the function is used, it can be automatically deduced according to the passed parameters:
void main() { int x = 1; int y = 2; cout << "max(1, 2) = " << Max(x, y) << endl; //Automatic derivation of parameter types cout << "max(1, 2) = " << Max<int>(x, y) << endl;//Display type call float a = 2.0; float b = 3.0; cout << "max(2.0, 3.0) = " << Max(a, b) << endl; system("pause"); return; }
Operation screenshot:
3. Function template syntax
The so-called function template is actually to establish a general function. Its function type and formal parameter type are not specified, but are represented by a virtual type. This generic function is called a function template. All functions with the same function body can be replaced by this template. There is no need to define multiple functions, just define them once in the template. When calling a function, the system will replace the virtual type in the template according to the type of the argument, so as to realize the functions of different functions.
3.1 function template definition form
It consists of the following three parts: Template description + Function definition + function template call
1. Template description
template < Type form parameter table >
Form of type parameter:
typename T1 , typename T2 , ...... , typename Tn
Or class T1, class T2 , …… , class Tn
(Note: typename and class have the same effect)
2. Function definition
Type Function name (form parameter table){
}
Note: the generic parameter of the template description must appear once in the function definition
Generic type parameters or general type parameters can be used in the function parameter table
3. Function template call
max<int>(a, b); // Explicit type call
max(a, b); // Automatic data type derivation
4. Function template and function overloading
4.1 function templates cannot convert implicit data types
When common function overloading and function template exist at the same time:
template <typename T> void Swap(T& a, T& b) { T t; t = a; a = b; b = t; cout << "Swap The template function was called" << endl; } void Swap(char &a, int &b){ int t; t = a; a = b; b = t; cout<<"Swap Ordinary functions are called"<<endl; }
Execution: char cNum = 'c'; int iNum = 65;
Swap(cNum, iNum);
Operation screenshot:
Screenshot of calling when there is only function template:
The error prompt is: there is no function template "Swap" instance matching the parameter list. The parameter type is (char, int)
Thus:
In the first case, the template function and ordinary function coexist, and the parameter type matches the ordinary overloaded function better, so the ordinary function is called.
In the second case, there is no ordinary function, and the function template will not perform implicit data type conversion.
Conclusion: implicit data type conversion is not provided and must be strictly matched.
Difference between function template and ordinary function conclusion:
Both are allowed to coexist;
Function templates do not allow automatic type conversion.
4.2 when the function template and ordinary functions are consistent with the call, ordinary functions are preferred
Now change the function template parameters and overloaded functions:
int Max(int a, int b) { cout << "call int Max(int a, int b)" << endl; return a > b ? a : b; } template<typename T1, typename T2> T1 Max(T1 a, T2 b) { cout << "call T Max1(T1 a, T2 b)" << endl; return a > b ? a : b; }
When both the function template and the ordinary function are consistent with the call, the ordinary function is preferred
int a = 1; int b = 2; cout<<"Max(a, b)"<<Max(a, b)<<endl;
Operation screenshot:
4.3 if the function template will produce a better match, use the function template
int a = 1; int b = 2; char c = 'a'; //If the function template will produce a better match, use the function template Max(c, a); Max(1.0, 2.0); //Or explicitly use the function template and use the < > type list Max<>(a, b);
Operation screenshot:
4.3 function templates and ordinary functions together, and call rules
1 function templates can be overloaded like ordinary functions
2 C + + compiler gives priority to ordinary functions
3 if the function template can produce a better match, select the template
4. You can restrict the compiler to match only through the template through the syntax of the empty template argument list
5. Function template calling mechanism
Observed by disassembly language:
1. The compiler does not process the function template into any type of function
2. The compiler generates different functions from the function template through specific types