模板学习笔记1

传智播客——进阶day9：

函数模板

1、函数模板引例

简单的例子：
声明：

template<typename T>//template告诉编译器我要开始泛型编程了，看到T别报错
void myswap(T &a, T &b)
{
    T c;
    c = a;
    a = b;
    b = c;
}

函数模板的调用：
1.显示类型 调用
2. 自动类型 推导（不常用）

    int x=10;
    int y=20;
    myswap<int>(x,y);//显示类型 调用
    myswap(x,y);//自动类型 推导

2、函数模板当函数参数：
让你对字符数组，int型数组进行排序

main:
int arry[]={1,2,3,32,15,23,5,2};
int len=sizeof(arry)/sizeof(*arry);
mysort<int，int>(arry,len);  //<...>是类型的参数化列表
-----------------------------------------------------
template<typename T,typename T2>
int mysort(T *arry,T2 size)
{
   ...
}

函数模板本质：类型参数化

3、函数模板遇上函数重载：
1.简单的例子：

void swap(int,char){}

template<typename T>
void swap(T &a,T &b){}
------------------------------
int main()
{
int a=10;
char c='b';
swap(a,c);//普通类型调用，可以进行隐式类型转换
swap(c,a);//普通函数
swap(a,a);//调用函数模板（本质就是类型参数化），将严格按照类型匹配，不会进行类型自动转换
}

2.普通函数和函数模板在一起使用的规则

1. 函数模板可以像普通函数一样被重载
2. 编译器优先考虑普通函数
3. 函数模板可以产生更好匹配就选择模板
4. 可以通过空模板实参列表的语法限定编译器只通过模板匹配

template<typename T>
T Max(T,T){}

int Max(int,int){}
-----------------------------
int a=1,b=2;
Max(a,b);//使用普通函数
Max<>(a,b);//使用模板函数
Max(3.0,4.1);//使用函数模板
Max('a',3.0);//使用普通函数

4、C++编译器的模板机制：
gcc编译过程：
预处理，编译，汇编，链接

Gcc  *.c -o 1exe//总
Gcc  -E  1.c  -o 1.i//预处理：宏定义宏展开
Gcc  -S  1.c  -o 1.s//通过编译器成汇编程序（文本)
Gcc  -E  1.c  -o 1.o//通过汇编器转成二进制
Gcc  1.o  -o 1exe

函数模板机制结论：

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

其实函数模板机制是大牛们帮我们写了函数原型，调用一次生成一次匹配的函数，所以函数模板可以和普通函数在一起发生函数重载。

类模板

1、类模板引例
用于两个或多个类，他们的功能是一样的
1. 类模板用于实现所需数据的类型参数化
2. 类模板用在链表，图等数据结构方面，这些数据结构的表示和算法不受所存放元素类型的影响

2、单个类模板语法

//定义类模板
template<typename T>//<class T>这两个都是一样的
class A
{
public:
    A(int a = 0)
    {
        this->a = a;
    }
    void printA()
    {
        cout << "a : " << a << endl;
    }
private:
    T a;
};
//类模板做函数参数,C++编译器需要具体的类，所以是A<int> &
void UseA(A<int> &a)
{
    a.printA();
}
----------------------------------------------------------
main:
A<int> a1(11),a2(12),a3(15);//模板类是抽象的，需要进行类型具体化
a1.printA();
UseA(a1);
UseA(a2);
//模板类（本身就是类型化的）=====具体的类======>定义具体变量

3、单个类模板语法
接着上面的程序：
1.从模板类派生普通类

//子模板类派生时，需要具体化模板类，C++编译器需要知道父类的数据类型具体是什么样子的
//也就是要知道父类所占内存到底是多少，只有数据类型确实下来，才知道如何分配内存

class B:class A<int>//B就是个普通的类
{
public:
    B(int a=10,b=20):A<int>(a)
    {
        this->b=b;
    }
    printb()
    {
        cout<<"a:"<<a<<" b:"<<b<<endl;
    }
private:
    int b;
}
//继承调用规则：子类调用父类的调用规则，因此B调用有参数的A的构造函数
------------------------------------------------------------------
main:
    B b1(1,2);
    b1.printb();

2.从模板类派生模板类

template<typename T>
class C:public A<T>
{
public:
        C(T c,T a):A<T>
        {
            this->c=c;
        }
        vois printc()
        {
            cout<<"c:"<<c<<endl;
        }
private:
    T c;
}
----------------------------------
main:
    C<int> c1(1,2);
    c1.printc();