C++函数模板&类模板

函数模板

模板概念及语法

　　主要目的，简化代码，减少重复代码。基本语法格式：  template<class T> 或者 template<typename T> //末尾不加分号  

template <class T> //等价于 template <typename T>

void mySwap(T &a, T &b){
    T tmp = b;
    b = a;
    a = tmp;
}

void test02(){
    int a = 10, b = 20;
    //自动推导类型，里面必须有参数，而且参数类型必须相同，因为两者是同一个类型T，这也是类型参数化的意义
    mySwap(a, b);
    //显式调用，显式指定类型
    mySwap<int>(a, b);

    cout << "a = " << a << "b = " << b << endl;
}

函数模板与普通函数 

1.与类模板区别

　　template声明下面是函数定义，则为函数模板，否则为类模板。注意：每个函数模板前必须有且仅有一个template声明，不允许多个template声明后只有一个函数模板，也不允许一个template声明后有多个函数模板。

2. 与普通函数的区别

　　（1）函数模板不可以进行隐式类型转换，普通函数可以进行隐式类型转换；

　　（2）两者的调用规则：

　　　　①若函数模板和普通函数出现了重载（两者仅仅参数类型不同，一个为T，一个为具体类型），优先使用普通函数调用，若普通函数没有实现，则会出现“无法解析命令”的错误，不会因此而调用函数模板；

　　　　②如果想强制调用模板，可以使用空函数列表

　　　　③函数模板可以发生重载（参数类型和个数等）

　　　　④如果函数模板可以更好的匹配，优先调用函数模板，如果函数模板和普通函数都能匹配，优先调用普通函数（这一点和①类似）。

3. 模板机制剖析

　　（1）模板不是万能的，不能处理所有的数据；

　　（2）函数模板不可以直接调用，需要编译器处理成模板函数后才能调用；

　　（3）编译器对函数模板进行两次编译，一次是在声明的地方对模板代码（函数模板）进行编译，一次对调用时对参数替换后的代码（模板函数）进行编译。

template <class T>
bool myComp(T &a, T &b){

    cout << "模板函数调用" << endl;
    if (a == b)
        return true;
    else
        return false;
}

//函数模板重载
template <class T>
bool myComp(T &a, T &b, T &c){

    cout << "模板函数调用" << endl;
    if (a == b == c)
        return true;
    else
        return false;
}

////如果int类型的参数调用上述函数模板，会替换参数类型处理为模板函数如下
//bool myComp(int &a, int &b){
//    if (a == b)
//        return true;
//    else
//        return false;
//}

bool myComp(int a, int b){

    cout << "普通函数调用" << endl;

    if (a == b)
        return true;
    else
        return false;
}

void test02(){
    int a = 10, b = 20, c = 40;
    float d = 40;

    //普通函数和模板函数都可以匹配，优先调用普通函数
    myComp(a, b);
    //普通函数中形参可以隐式转换（隐式强转），函数模板不可以
    myComp(a, d);
}

4. 函数模板的局限性

　　（1）模板不能解决所有数据类型；

　　（2）如果出现不能解决的类型，可以通过数据类型具体化来满足要求；

　　（3）数据类型具体化语法： template <> 返回值 函数名 <具体类型> (参数) ，将数据类型具体化，仅仅是数据类型，不能修改返回值类型和函数名。

　　（4）当具体化和参数化同时匹配时，优先使用具体化

class Person{
public:
    Person(string name, int age){
        m_Name = name;
        m_Age = age;
    }

    string m_Name;
    int m_Age;

};

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

//自定义数据无法适应模板，会报如下错误
//error C2678: 二进制“==”: 没有找到接受“Person”类型的左操作数的运算符(或没有可接受的转换)
//另外，将数据类型具体化，仅仅是数据类型，不能修改返回值类型和函数名
template<> bool myComp<Person>(Person &a, Person &b){
    if (a.m_Age == b.m_Age){
        return true;
    }
    else
        return false;
}

void test02(){
    int a = 10, b = 20;
    int ret = myComp(a, b);
    cout << "ret = " << ret << endl;

    
    Person p1("tom", 1);
    Person p2("jerry", 1);
    int ret1 = myComp(p1, p2); 

    cout << "ret = " << ret1 << endl;
}

类模板

1. 基本使用

　　与函数模板相同，紧跟在template声明后，同样一个template对应一个类模板。

　　与函数模板的区别：（1）类模板不支持自动类型推导；（2）数据类型可以有默认参数.

//类模板可以有默认参数
//template<class NameType, class AgeType = int>
template<class NameType, class AgeType>
class Person{
public:
    Person(NameType name, AgeType age){
        m_Name = name;
        m_Age = age;
    }

    NameType m_Name;
    AgeType m_Age;
};

void test02(){
    //类模板不支持自动类型推导
    //缺少 类模板 "Person" 的参数列表
    //Person p("啊呀呀", 10);

    Person<string, int> p("啊呀呀", 10);
}

2. 成员函数创建时机

　　成员函数只有在编译或运行时才会创建，仅仅写出来不会报错，如示例所示

class Person1{
public:
    void showPerson1(){
        cout << "Person1调用" << endl;
    }
};

class Person2{
public:
    void showPerson2(){
        cout << "Person2调用" << endl;
    }
};

template<class T>
class myclass{
public:
    T obj;

    void func1(){
        obj.showPerson1();
    }

    void func2(){
        obj.showPerson2();
    }
};

void test02(){
    myclass<Person1>tmp;

    tmp.func1();

    //成员函数只有在程序编译或运行时才会创建，只是写出来不会报错，在编译或运行时会报错
    //tmp.func2();
}

3. 类模板作函数的参数

　　有三种方式：（1）显示指定类型；（2）参数模板化；（3）整体模板化

template<class NameType, class AgeType>
class Person{
public:
    Person(NameType name, AgeType age){
        m_Name = name;
        m_Age = age;
    }

    void showPerson(){
        cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
    }

    NameType m_Name;
    AgeType m_Age;
};

//1.显式指定类型
void doWork(Person<string, int> &p){
    p.showPerson();
}

//2.参数模板化
template<class NameType, class AgeType>
void doWork2(Person<NameType, AgeType> &p){
    p.showPerson();
}

//3.整体模板化
template<class PersonType>
void doWork3(PersonType &p){
    p.showPerson();
}

void test02(){
    Person<string, int>p("tom", 10);;
    doWork(p);
    doWork2(p);
    doWork3(p);
}

4. 继承中的类模板

 　　如果基类是模板类，则子类需要告诉编译器基类中的T是什么类型，如果不告诉编译器无法通过，不能分配内存。

template<class T>
class Person{
public:
    T m_Age;
};
//如果子类不显式标明父类中模板的数据类型，会报错：缺少类模板的参数列表
class Son :public Person<int>{

};

//子类中标明的数据类型也可以是模板
template<class T1, class T2>
class Son1 :public Person<T2>{
    T1 m_name;
};

void test02(){
    Son1<string, int>son; //标明Person类中的T为int型，T1为string
}

5. 类模板下的类外成员函数实现

 　　普通的类外成员函数实现时，需要将作用域写上即可，但在类模板下，需要将作用域写为类模板形式。另外在类外实现时，需要在类内声明。

template<class T1, class T2>
class Person{
public:
    //类内实现
    Person(T1 name, T2 age;
    //{
    //    this->m_Name = name;
    //    this->m_Age = age;
    //}

    void showPerson();
    //{
    //    cout << "name: " << this->m_Name << "age: " << this->m_Age << endl;
    //}

    T1 m_Name;
    T2 m_Age;
};

//类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){
    this->m_Name = name;
    this->m_Age = age;
}

template<class T1, class T2>
void Person<T1, T2>::showPerson(){
    cout << "name: " << this->m_Name << "age: " << this->m_Age << endl;
}

void test02(){
    Person<string, int>p("tom", 10);
    p.showPerson();
}

6. 类模板分文件编写问题

　　一般进行分文件编写时，.h,.cpp分别写声明和实现，但是由于类模板的成员函数运行阶段才去创建，导致包含.h头文件，不会创建函数的实现，无法解析外部命令，此时

建议类模板不要分文件编写，写到一个类中即可，类内进行声明和实现，最后文件后缀改为hpp.

类模板下的友元函数

1. 类内友元函数实现

　　类内友元函数实现， friend void printPerson(Person<T1, T2> &p) 

template<class T1, class T2>
class Person{
    //友元函数遇到类模板，在类内实现
    friend void printPerson(Person<T1, T2> &p){
        cout << "name : " << p.m_Name << " age :" <<p.m_Age<< endl;
    }

public:
    Person(T1 name, T2 age){
        this->m_Name = name;
        this->m_Age = age;
    }

    T1 m_Name;
    T2 m_Age;
};

void test02(){
    Person<string, int> p("tom", 10);
    printPerson(p);
}

2. 类外友元函数实现

　　类外实现时，需要在类内通过空参数列表，告诉编译器，这是模板函数的声明，不加<>表示普通函数声明。另外，需要让编译器提前看到函数及类的声明。

template<class T1, class T2>
class Person;

//让编译器提前看到printPerson声明，但里面有Person声明，需要提前声明Person类
template<class T1, class T2> 
void printPerson(Person<T1, T2> &p);

template<class T1, class T2>
class Person{
    //友元函数类外实现时，需要在类内通过空参数列表，告诉编译器，这是模板函数的声明
    friend void printPerson<>(Person<T1, T2> &p);
    //{
        //cout << "name : " << p.m_Name << " age :" <<p.m_Age<< endl;
    //}

public:
    Person(T1 name, T2 age){
        this->m_Name = name;
        this->m_Age = age;
    }

    T1 m_Name;
    T2 m_Age;
};

template<class T1, class T2>
void printPerson(Person<T1, T2> &p){
    cout << "name : " << p.m_Name << " age :" << p.m_Age << endl;
}

void test02(){
    Person<string, int> p("tom", 10);
    printPerson(p);
}