函数模板与函数重载
一，什么是函数重载
1，在理解什么是函数重载之前，先理解一下函数符号生成规则，在C语言中，函数符号的生成只与函数名相关，这个是什么意思呢？如下代码：
#include<stdio.h>
int sum(int a,int b){return a+b;}
double sum (double a,double b){return a+b;}
float sum (float a,float b){return a+b;}
这些代码在main.c文件下运行，会出现这样的报错：
main.c:error c2371: "sum"重定义。
（1）对于使用__cdecl调用约定的函数，在函数名称前加一下划线，不考虑参数和返回值。
例如上述三个函数: 都是_sum
（2）对于使用__fastcall调用约定的函数，在函数名称前后各加一@符号，后跟参数的长度，不考虑返回值。
例如 int __fastcall Test(int n)的修饰名称为@Test@4；
（3）对于使用 __stdcall 标准调用约定的函数，在函数名称前加一下划线，名称后加@符号，后跟参数的长度，不考虑返回值。
例如 int __stdcall Test(int n,int m)的修饰名称为 _Test@8
2，在C++中，函数符号的生成与函数名，函数的返回值，函数的形参列表，即函数原型有关，如在main.cpp中：
#include<iostream.h>
using namespace syd;
int sum(int a,int b){return a+b;}
double sum (double a,double b){return a+b;}
float sum (float a,float b){return a+b;}
生成的函数符号如格式：？函数名称@@YA返回值参数列表@Z/Z(@Z表示有形参，Z表示没有形参)
int 型： ?sum@@YAHHH@Z
double型： ?sum@@YANNN@Z
float型： ?sum@@YAMMM@Z
调用约定： YA _cdecl YG _stdcall YI _fastcall
返回值类型：bool _N int H double N float M
所以对于C++编译器来说，上述三个函数生成的函数符号完全不相同，即为三个不同的函数，
如：bool compare (int a, int b);来说，函数符号为：?compare@@_NHH@Z
从上面可以知道：函数重载的条件是：1，函数名同名；2，函数的参数不同；3，同作用域
（1）函数的参数顺序不同可以作为重载的条件；
（2）函数参数的个数不同可以作为重载的条件；
（3）函数的参数不同也可以作为重载的条件；
调用约定
_cdecl c语言标准调用约定
_stdcall windows标准调用约定
_fastcall 快速调用约定
_thiscall 类成员方法的调用约定
对于形参的开辟和清理：
cdecl 由调用方开辟，由调用方清理；
stdcall 由调用方开辟，被调用方清理；
fastcall 前两个参数不开辟内存，之后的参数由调用方开辟，被调用方清理
二，模板函数的重载
1，什么是函数模板？
为什么要讲函数模板呢，因为对于C++来说，函数虽然允许重载，但是如果要实现任意两个数之和这种功能，如果用函数重载的话，需要写很多种重载函数，十分不方便，这个时候需要一个能够统一的智能函数，不管是什么类型，都能实现两数之和的这个函数功能，这个时候就需要函数模板。
函数模板允许程序员编写一个单独的函数定义，以处理许多不同的数据类型，而不必为每个使用的数据类型编写单独的函数。函数模板不是实际的函数，而是编译器用于生成一个或多个函数的 “模具”。在编写函数模板时，不必为形参、返回值或局部变量指定实际类型，而是使用类型形参来指定通用数据类型。当编译器遇到对函数的调用时，它将检查其实参的数据类型，并生成将与这些数据类型配合使用的函数代码。
template<模板参数表>
返回类型 函数名(形式参数表)
{
……；
}//函数体
template为函数模板的关键字，如求两数之和函数模板为：
template<typename group>
group Sum(group a, group b)
{
return a+b;
}
int main()
{
int a = 10;
int b = 20;
double c = 2.1;
double d = 2.8;
cout << Sum(a, b) << endl;
cout << Sum(c, d) << endl;
return 0;
}
什么是函数模板，什么是模板函数？template group Sum(group a, group b){return a+b;}是函数模板，其 实例化之后的函数Sum 是模板函数，这个实例化过程不是宏替换，而是重命名，即typedef int Group
模板函数的推演分为隐式推演和显式推演：
隐式推演就是编译器推演，显式推演是程序猿指定好这个函数采用何种参数：如
Sum<int>(a,b); Sum<double>(a,b);
程序员为这个函数指定参数类型。
2，什么是函数模板的重载？
#include<iostream>
using namespace std;
template <class T>
void fun(T a, T b)
{
}
template <class T>
void fun(T a)
{
}
int main ()
{
fun(11,22);
fun(23);
return 0;
}
这就是模板函数的重载，fun如果是两个参数，那么就实例化fun(T a, T b)，如果是一个参数，那么就实例化fun(T a)。
template<class T> void fun (T a) {}
template<class U> void fun (U a) {}
那么这两个算模板函数的重载吗？
#include<iostream>
using namespace std;
template <class U>
void fun( U b)
{
}
template <class T>
void fun(T a)
{
}
int main()
{
fun(12);
return 0;
}
系统会出现这样的报错：
1>------ 已启动生成: 项目: C++上课代码集合, 配置: Debug Win32 ------
1>函数重载.cpp
1>C:\Users\ccayj\source\repos\C++上课代码集合\函数重载.cpp(10,6): error C2995: “void fun(U)”: 函数 模板已经定义
1>C:\Users\ccayj\source\repos\C++上课代码集合\函数重载.cpp(5): message : 参见“fun”的声明
1>C:\Users\ccayj\source\repos\C++上课代码集合\函数重载.cpp(16,2): error C2065: “fun”: 未声明的标识符
1>已完成生成项目“C++上课代码集合.vcxproj”的操作 - 失败。
========== 生成: 成功 0 个，失败 1 个，最新 0 个，跳过 0 个 ==========
显而易见，上述代码不算函数模板重载，那么是怎么个原因呢？
在函数模板推演的过程中，typedef int T void fun (T a){} 和 typedef int U void fun (U a),都被推演为整形，对于编译器来说，这两个重定义了，所以不能函数重载，我们不能拿函数模板名称不同还辨别函数重载。
下面两个模板函数算重载吗？
#include<iostream>
using namespace std;
template <class T>
void fun( T b)
{
}
template <class T>
void fun(T a, int x)
{
}
int main()
{
fun(12);
fun(12, 23);
return 0;
}
1>------ 已启动生成: 项目: C++上课代码集合, 配置: Debug Win32 ------
1>函数重载.cpp
1>C++上课代码集合.vcxproj -> C:\Users\ccayj\source\repos\C++上课代码集合\Debug\C++上课代码集合.exe
========== 生成: 成功 1 个，失败 0 个，最新 0 个，跳过 0 个 ==========
这个就是模板函数的重载，编辑器在编译的时候，因为形参数量不同，在推演之后生成的函数符号也不相同，构成重载。
3，模板函数和宏替换有什么区别？
#include<iostream>
using namespace std;
template <class T>
void fun( T b)
{
T x, y; //TX =>
//TY =>
}
int main()
{
int a = 10;
int* p = &a;
fun(a); //TA =>
fun(p); //TP =>
return 0;
}
那么TA，TP，fun§ 调用的TX，TY应该被推演成什么类型？
我们应该很容易的就能推演出：TA => int ； TP => int*
那么TX，TY应该被推演为什么？
TX => int* ; TY => int ；
这个结果对还是不对，我们在刚才已经说了，这个实例化过程不是宏替换，那么这个结果是对还是不对？
其实是不对的，正确的应该是：
TX => int* ; TY => int* ;
那fun（a）对于的TX，TY应该是什么类型，都是int型；
typedef int T
void fun (T a)
{
T x,y; //x和y的类型都是int
}
typedef int* T
void fun (T a)
{
T x,y;//x和y的类型都是int*
}
宏替换和模板函数采用的重命名不同：
#define PINT int*
typedef int* SINT;
int main()
{
PINT x, y;
SINT a, b;
}
x和y类型一样吗？不一样，x是int*，y是int类型，这是宏替换；
a和b类型都是int*；
可以使用头文件typeinfo中的typeid(x).name 检验类型；
#include<iostream>
using namespace std;
template<class T>
void fun(T* a)
{
T x, y;
//这个T是什么类型，x是什么类型，y是什么类型？
}
int main()
{
int a = 10;
int* p = &a;
fun(p);
return 0;
}
为什么T是整型而不是指针？
根本原因是因为：我们在定义指针是，我们的*是和变量名结合，所以在我们推演的时候，推演成为了typedef int T；
所以我们的T,x,y都是int型；
#include<iostream>
#include<typeinfo>
using namespace std;
template<class T> //一般的模板函数
void fun(T a)
{
}
template<class T> //部分特化的模板函数
void fun(T *a)
{
}
void fun(char *p) //完全特化的模板函数
{
}
int main()
{
int a = 10;
int* p = &a;
fun(a);
fun(p);
return 0;
}
//这个概念是什么概念呢？
//为什么可以编译通过呢？
//这三个函数有什么差别呢？
为什么可以编译通过呢？
从函数重载来说，这三个函数推演之后，生成的函数符号不同，所以可以重载，void fun(T a)， 只要是个类型我都可以接受，class 、int、double、char都行，我都可以推演；但是 void fun(T *a)，我只能接受指针类型的参数；void fun(char *a)，只能接受char类型的指针。
from 西安图论教育杨和平老师