1、函数模板

https://download.csdn.net/download/u014749668/10639718
泛型编程：让类型参数化

基本语法

//让 类型参数化 ===, 方便程序员进行编码
// 泛型编程 
//template 告诉C++编译器 我要开始泛型编程了 .看到T, 不要随便报错
//template <typename T>
//template <typename T，typename F>

函数模板做函数参数
void myswap(T &a, T &b)
{
    T c = 0;
    c = a;
    a = b;
    b = c;
    cout << "hello ....我是模板函数 欢迎 calll 我" << endl;
}

显示调用和自动推导

int x = 10; 
int y = 20;

//myswap<int>(x, y);     //1 函数模板 显示类型 调用
//myswap(x, y);          //2 自动类型 推导
printf("x:%d y:%d \n", x, y);

重载：发生在同一作用域，函数参数不同
重写：（1）父子关系
（2）虚函数重写发生多态
重定义（3）普通函数重定义

函数模板遇上函数重载

函数模板：严格的按照类型类型匹配，不会进行类型转换
普通函数：可以进行隐士类型转换

/*
函数模板不允许自动类型转化
普通函数能够进行自动类型转换
*/

/*
    1 函数模板可以像普通函数一样被重载
    2 C++编译器优先考虑普通函数
    3 如果函数模板可以产生一个更好的匹配，那么选择模板
    4 可以通过空模板实参列表的语法限定编译器只通过模板匹配
*/


#include "iostream"
using namespace std;


int Max(int a, int b)
{
    cout<<"int Max(int a, int b)"<<endl;
    return a > b ? a : b;
}

template<typename T>
T Max(T a, T b)
{
    cout<<"T Max(T a, T b)"<<endl;
    return a > b ? a : b;
}

template<typename T>
T Max(T a, T b, T c)
{
    cout<<"T Max(T a, T b, T c)"<<endl;
    return Max(Max(a, b), c);
}


void main()
{
    int a = 1;
    int b = 2;

    cout<<Max(a, b)<<endl; //当函数模板和普通函数都符合调用时,优先选择普通函数
    cout<<Max<>(a, b)<<endl; //若显示使用函数模板,则使用<> 类型列表

    cout<<Max(3.0, 4.0)<<endl; //如果 函数模板产生更好的匹配 使用函数模板

    cout<<Max(5.0, 6.0, 7.0)<<endl; //重载

    cout<<Max('a', 100)<<endl;  //调用普通函数 可以隐式类型转换 
    system("pause");
    return ;
}

c++编译器的模板机制

预处理
编译
汇编
链接

c++编译器 通过函数参数类型生成了 函数原型，为程序员减少了编码量

template <typename T>
void myswap(T &a, T &b)
{
    T c = 0;
    c = a;
    a = b;
    b = c;
    cout << "hello ....我是模板函数 欢迎 calll 我" << endl;
}

-----------------------------------------------------------------------

void main()
{
    {
        int x = 10; 
        int y = 20;

        myswap<int>(x, y); //1 函数模板 显示类型 调用

        printf("x:%d y:%d \n", x, y);
    }

    {
        char a = 'a'; 
        char b = 'b';
        myswap<char>(a, b); //1 函数模板 显示类型 调用
        printf("a:%c b:%c \n", a, b);
    }
    return 0;
}

==============================================================================

汇编代码：
call    __Z6myswapIiEvRT_S1_  //63 ===>135行
135：__Z6myswapIiEvRT_S1_:  //

call    __Z6myswapIcEvRT_S1_  //78====>172行
172：__Z6myswapIcEvRT_S1_:  //

函数模板机制结论
编译器并不是把函数模板处理成能够处理任意类的函数
编译器从函数模板通过具体类型产生不同的函数
编译器会对函数模板进行两次编译
（1）在声明的地方对模板代码本身进行编译；
（2）在调用的地方对参数替换后的代码进行编译。