C++函数模板和类模板

函数模板和类模板的作用？

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

类模板：建立一个通用的类，可以不具体指定类里面的变量类型，以一个虚拟类型来代表。

区别：类模板没有自动推导类型的使用方式，所以使用时要指定推导类型

              类模板在模板参数列表中可以有默认推导类型:

例：template<typename T,typename Q = int>

        class Person{

        T name;

        Q age;

};

创建时Person <string>p1;

————————————————分割线——————————————————

类模板对象作为函数传参时：

Void fun（Person<int,string> &p）//指定类型，直接传入

Template<class T,class Q>

Void fun(Person<T,Q> &p) //参数模板化

template<class T>

Void fun(T &p) //类模板化

类模板与继承：

子类继承的父类是一个类模板时，子类在声明时要指出父类中的虚拟类型。

class Son:public Base<int>

{

}；

————————————————分割线——————————————————

函数模板和普通函数调用规则：

一、同名的普通函数和函数模板，如果调用时两者都能实现，优先调用普通函数。

二、可以通过空模板参数强制调用函数模板。

三、函数模板可以发送重载。

四、如果函数模板能发生更好的匹配，优先调用函数模板。

示例代码：

#include <iostream>
using namespace std;

void fun(int data)
{
    cout <<"fun"<< endl;
}

template <typename T>
void fun(T data)
{
    cout << data << endl;
}

template <typename T>
void fun(T data,T data_1)
{
    cout << "2222" << endl;
}

int main()
{
    fun(10);
    fun<>(10);  //  通过空模板参数列表调用函数模板
    fun("adsad");
    fun(10,6);

    return 0;
}

——————————————————分割线——————————————————

模板的局限性：

一、模板不是万能的。

template<typename T>
void fun(T a,T b)
{
    a=b;
}


int arr_1[10];
int arr_2[10];
fun(arr_1,arr_2);//如果传入的是两个数组则无法实现

再看

class Person{
public:
    Person()
    {
        name ="man";
        age  =10;
    }

    string name;
    int    age;
};

/*普通函数模板*/
template<typename T>
bool fun(T a,T b)
{
    if(a == b)
    return true;
    else
    return false;
}

/*具体化函数模板，在开头加上空模板参数列表，并且通过名称来指出类型*/
template<> bool fun(Person &a,Person &b)
{
    if(a.name == b.name && a.age == b.age)
    return true;
    else
    return false;
}



int a =1;
int b =2;
fun(1,2);//正常调用


Person p1;
Person p2;
fun(p1,p2);//传入的是自定义数据类型，无法调用普通函数模板。
            //需要创建具体化Person数据类型的模板来处理

——————————————————分割线——————————————————

类模板中成员函数创建时机

类模板的成员函数和普通类的成员函数创建时机不同：

普通类的成员函数在一开始就可以创建

类模板的成员函数在调用时才创建

#include <iostream>
using namespace std;

/*类模板成员函数的创建时机*/

class Man{
     public:

        void man()
        {
            cout << "man"<<endl;
        }
};

class Woman{
    public:

    void woman()
    {
        cout << "woman"<<endl;
    }
};


//类模板
template<typename T>
class Person{
    public:

    void fun1()
    {
        obj.man();//需要传man类成员函数才能调用
    }

    void fun2()
    {
        obj.woman();//需要传woman类成员函数才能调用
    }

    T obj;

};


int main()
{
    Person <Woman>p1;//创建对象但不调用，发现编译运行通过，说明类模板的成员函数还没有创建
    
    p1.fun1();//此时报错，因为fun1里面调用的是Man类里的成员函数，而我们指定的推导类型为Woman。
    p1.fun2();//说明类模板的成员函数是在调用时创建的！！！
    
    return 0;
}