C++从入门到精通【Day6】模板

        面向对象学习完之后，进入下一阶段的学习，这一阶段主要针对C++泛型编程和STL技术作学习了解。泛型编程是另一种编程思想，主要利用到的技术是模板。

---

一、模板的定义

        模板就是建立通用的模具，大大提高复用性。例如生活中的证件照模板、PPT模板等。

模板的特点：

        ···模板不可以直接使用，它只是一个框架

        ···模板的通用并不是万能的

C++提供了两种模板机制：函数模板和类模板

二、函数模板

函数模板作用：

        建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来表示。

1.函数模板的基本语法

 语法：

template<typename T>
函数声明或定义

其中

template ···声明创建模板

typename ··· 可以用class替代，其后面的符号T代表通用数据类型，

T ··· 通用的数据类型，名称可以替换，通常为大写字母

例：交换函数中的逻辑结构是十分相似的，但是它们的传入参数可能类型不同，对于每一种数据类型都要重新写一遍交换函数，此时我们就可以使用模板来简化这个操作

template<typename  T> //声明一个模板，告诉编译器T是一个通用数据类型
void mySwap(T &a,T &b) //模板函数，交换两个变量的值
{
    T temp = a;
    a = b;
    b = temp;
}
int main()
{   
    int a = 10,b = 20;
    //使用方法一：自动类型推导，由编译器自己推导a和b的数据类型
    mySwap( a , b );
    cout << "a = " << a << " b = " << b << endl; 
    //使用方法二：显示指定类型，由程序员自己指定a和b的数据类型
    mySwap<int>( a , b );
    cout<<"a = " << a << " b = " << b << endl;
    return 0;
}

2.函数模板注意事项

（1）函数模板中typename可以替换成class，效果是一样的

（2）自动类型推导，必须是数据类型一致的T才可以使用

（3）模板必须要确定出T的数据类型，才可以使用

3.普通函数与函数模板

（1）普通函数与函数模板的区别

        ①普通函数调用可以发生隐式类型转换

        ②函数模板 用自动类型推导时，不可以发生隐式类型转换

        ③函数模板 用显示指定类型时，可以发生隐式类型转换

隐式类型转换就是数据类型与传入参数不一致的数据在函数调用时，在编译时它的数据类型被自动转换成了与传入参数一致的数据类型。例如：

template<class T>
T myPlus(T a,T b)
{
    return a+b;
}

int main()
{   
    int a = 10;
    char b = 'b';
    cout<<myPlus(a,b)<<endl;  //自动类型推导，编译错误，不可以发生隐式类型转换
    cout<<myPlus<int>(a,b)<<endl; //显示类型转换，编译正确，可以发生隐式类型转换
    return 0;

（2）普通函数与函数模板的调用规则

①如果函数模板和普通函数都可以实现，优先调用普通函数

②可以通过空模板参数列表来强制调用函数模板

③函数模板也可以发生重载

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

例：

int myPrint( int a)  //普通函数
{
    cout<<" 调用普通函数 "<<endl;
}
template <class T> //函数模板
T myPrint( T a)
{
    cout<<" 调用函数模板 "<<endl;
}
template <class T> //重载的函数模板
T myPrint( T a, T b)
{
    cout<<" 调用重载函数模板 "<<endl;
}
int main()
{   
    myPrint(1);  //优先调用普通函数
    myPrint<>(1); //通过空模板参数调用函数模板
    myPrint(1,2); //调用了重载的函数模板
    char a='a';
    myPrint(a); //函数模板产生更好的匹配，优先调用了函数模板
    return 0;
}

三、类模板

1.类模板的定义

        类模板的语法与函数模板是一致的，区别在于紧跟着的是一个类。

例：

template<class NameType, class AgeType> //类模板，自定义了两个数据类型
class Person
{   
    public:
        NameType m_Name;
        AgeType m_Age;
        Person(NameType name, AgeType age)
        {
            this->m_Name = name;
            this->m_Age = age;
        }
};

2.类模板和函数模板的区别

类模板与函数模板的区别主要有两点：

        ①类模板没有自动类型推导的使用方式

        ②类模板在模板参数列表中可以有默认参数

例：

template<class NameType = int , class AgeType = int> //只有类模板参数列表中可以有默认参数
class Person
{   
    public:
        NameType m_Name;
        AgeType m_Age;
        Person(NameType name, AgeType age)
        {
            this->m_Name = name;
            this->m_Age = age;
        }
        void show()
        {
            cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
        }
};
int main()
{   
    Person<> p("QHL", 18);  //自动类型推导，编译错误
    Person<string, int> p1("QHL", 18);  //显示指定类型，编译正确
    Person<int, int> p2(10086, 100);   //显示指定类型，编译正确
    p1.show();
    p2.show();
    return 0;
}

3.类模板中成员函数的创建和实现

类模板中成员函数和普通类中成员函数创建时机是有去别的：

···普通类中成员函数一开始就创建实例

···类模板中的成员函数在调用时才创建实例 

例：

template<class T>  //创建类模板
class A
{
public:
    T a;
    void func_01()
    {
        a.func_02();
    }
    void func_02()
    {
        cout<<"func_02调用成功"<<endl;
    }
};
int main()
{   
    A<int> a;
    a.func_01();//编译失败，调用时func_01时只创建了func_01函数实例而没有func_02函数实例
    a.func_02(); //编译成功，调用时func_02时创建了func_02函数实例
    return 0;
}

        类模板的成员函数的类外实现：

例：

template <class T>
class Father
{
    T a;
    Father(T a);
    void show();
};
template <class T>   //类外实现类模板构造函数
Father<T>::Father(T a)
{
    this->a=a;
}

template <class T> ///类外实现类模板成员函数
void Father<T>::show()
{
    cout<<a<<endl;
}

4.类模板对象作为函数参数

类模板实例化出的对象，向函数传参的方式一共有三种：

①指定传入的类型 ···直接显示对方的数据类型

②使参数模板化 ··· 将对象中的参数变为模板进行传递

③整个类模板化 ··· 将这个对象类型 模板化进行传递

例：

template<class T>
class Person
{
public:
    T name;
    Person(T name)
    {
        this->name = name;
    }
    void showPerson()
    {
        cout << " 姓名 "<<name << endl;
    }
};
  //指定传入类型
void printPerson1(Person<string> &p)
{
    p.showPerson();
}
 //使参数模板化
template<class T1>
void printPerson2(Person<T1> &p) 
{
    p.showPerson();
}

 //整个类模板化
 template<class T2>
void printPerson3(T2 &p) 
{
    p.showPerson();
}

int main()
{   
    Person<string>p("QHL");
    printPerson1(p);
    printPerson2(p);
    printPerson3(p);
    return 0;
}

5.类模板与继承

        当类模板碰到继承时：

···当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中的数据类型

···如果不指定，编译器无法给子类分配内存

···如果想灵活指定出父类中T的类型，子类也需变为类模板

template <class T>
class Fatehr
{
    T a;
};
class Son1:public Father<int> //继承类模板需要指定类型
{
    int b;
};
template <class T1,>        //或者将子类也变为类模板
class Son2:public Father<T1>  
{
    T1 t1;
};

6.类模板分文件编写

        类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决方式1：直接包含.cpp源文件  #include "XXX.cpp"

解决方式2：将声明和实现写道同一个文件中，并更改后缀名为.hpp，hpp是约定的名称 #include"XXX.hpp"

7.类模板与友元

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

template<class T>
class Person
{
    friend void showPerson(Person<T> p)  //全局函数类内实现
    {
        cout << p.name << endl;
    }
    public:
        T name;
        Person(T name)
        {
            this->name = name;
        }
};

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

template<class T>
class Person
{   
    friend void print(Person<T> p); 
    public:
        T name;
        Person(T name)
        {
            this->name = name;
        }
        

};

template <class T>
void print(Person<T> p)  //全局函数类外实现，需要指定T的类型
{
    cout << p.name << endl;
}