C++学习笔记——模板

模板是为了提高代码的复用性，它不可以直接使用，只是一个框架。模板是C++的一种编程思想（泛型编程）所使用的技术，C++提供了两种模板机制：函数模板和类模板。

函数模板：

函数模板作用：建立一个通用的函数以实现某种功能，函数的返回值类型和形参类型可以不用具体制定，用一个虚拟的类型表示。

语法：

template<typename T>

函数声明

注释：

template：声明创建模板；

typename：表明后面的符号是一种数据类型，也可以用class代替；

T：表示通用的数据类型，可以用别的名称来替换。

使用函数模板的两种方式：

1.自动类型推导，必须推导出一致的数据类型才可以使用，模板必须确定T的数据类型，才可以使用；

2.显示指定类型。

下面是一个利用模板实现的对不同类型数据的数组进行排序的小例子：

template<typename T>
void my_swap(T &a,T &b){
    T temp=a;
    a=b;
    b=temp;
}

//利用选择排序，由大到小
template<typename T>
void my_sort(T array[],int len){
    for(int i=0;i<len;i++){
        int max=i;
        for(int j=i+1;j<len;j++){
            if(array[max]<array[j]){
                max=j;
            }
        }
        if(max!=i){
            my_swap(array[max],array[i]);
        }
    }
}

template<typename T>
void print_array(T array[],int len){
    for(int i=0;i<len;i++){
        cout<<array[i]<<" ";
    }
    cout<<endl;
}

void test01(){
    int arr[]={5,4,10,9,7};
    int length= sizeof(arr)/ sizeof(int);
    my_sort(arr,length);
    print_array(arr,length);
}

int main() {
    test01();
    return 0;
}

普通函数与函数模板的区别：

1.普通函数调用时可以发生自动类型转换（隐式）；

2.函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换；

3.如果利用显示指定类型的方式，可以发生隐式类型转换。

普通函数与函数模板的调用规则：

1.如果普通函数与函数模板都可以实现，优先调用普通函数；

2.可以通过空模板参数列表强制调用函数模板；

3.函数模板可以发生重载；

4.如果函数模板可以产生更好的匹配，优先调用函数模板。

不过如果已经提供了函数模板，最好不要提供普通函数的实现。

函数模板也有局限性，如果有自定义的数据类型或者特殊的数据类型，就需要另加操作。比如比较两个对象的大小，如果是C++内置的数据类型，就没有问题，但如果是自己定义的数据类型，则提供的函数模板就不能使用，这个时候可以为自己的数据类型提供具体化的模板。

class Student{
public:
    Student(string name,int age){
        this->m_name=name;
        this->m_age=age;
    }
    string m_name;
    int m_age;
};

template<typename T>
bool my_compare(T &a,T &b){
    if(a==b){
        return true;
    }else{
        return false;
    }
}

//具体化的函数模板，优先级大于普通函数模板
template<> bool my_compare(Student &student1,Student &student2){
    if(student1.m_name==student2.m_name&&student1.m_age==student2.m_age){
        return true;
    }else{
        return false;
    }
}

void test01(){
    int a=10;
    int b=20;
    bool ret1=my_compare(a,b);
    if(ret1){
        cout<<"a==b"<<endl;
    }else{
        cout<<"a!=b"<<endl;
    }
    Student student1("li",16);
    Student student2("wang",16);
    bool ret2=my_compare(student1,student2);
    if(ret2){
        cout<<"student1==student2"<<endl;
    }else{
        cout<<"student1!=student2"<<endl;
    }
}

int main() {
    test01();
    return 0;
}

类模板：

作用：建立一个通用类，数据类型可以不具体指定，用一个虚拟的类型代表。

语法：

template<typename T>

类

注释：

template：声明创建模板；

typename：表明后面的符号是一种数据类型，也可以用class代替；

T：表示通用的数据类型，可以用别的名称来替换。

类模板与函数模板的区别：

1.类模板没有自动类型推导的使用方式；

2.类模板在模板参数列表中可以有默认参数。

类模板成员函数创建时间：

1.普通类中的成员函数一开始就可以创建；

2.类模板中的成员函数在调用时才创建。

类模板对象做函数参数（3种方式）：

1.指定传入的类型：直接显示对象的数据类型（常用）；

2.参数模板化：将对象中的参数变为模板进行传递；

3.整个类模板化：将对象类型模板化进行传递。

template<typename NameType,typename AgeType>
class Student{
public:
    Student(NameType name,AgeType age){
        this->m_name=name;
        this->m_age=age;
    }
    void showStudent(){
        cout<<"name: "<<this->m_name<<" age: "<<this->m_age<<endl;
    }
public:
    NameType m_name;
    AgeType m_age;
};

//指定传入的类型
void printStudent1(Student<string,int> &student){
    student.showStudent();
}

//参数模板化
template<typename T1,typename T2>
void printStudent2(Student<T1,T2> &student){
    student.showStudent();
}

//整个类模板化
template<typename T>
void printStudent3(T &student){
    student.showStudent();
}
void test01(){
   Student<string ,int>student("li",20);
   printStudent1(student);
   printStudent2(student);
   printStudent3(student);
}

int main() {
    test01();
    return 0;
}

类模板与继承：

注意点：

1.当子类继承的父类是一个类模板时，子类声明时要指定出父类中T的类型，如果不指定，编译器不能给子类分配空间；

2.如果想灵活指定出父类中T的类型，子类也要变为模板。

如果需要在类外实现类模板的成员函数，则需要加上模板的参数列表。

全局函数做某个类模板的友元：

1.全局函数类内实现：直接在类内声明友元；

2.全局函数类外实现：需要让编译器提前知道全局函数的存在。