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 = , b = ;
     //自动推导类型，里面必须有参数，而且参数类型必须相同，因为两者是同一个类型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 = , b = , c = ;
     float d = ;

     //普通函数和模板函数都可以匹配，优先调用普通函数
     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 = , b = ;
     int ret = myComp(a, b);
     cout << "ret = " << ret << endl;

     Person p1("tom", );
     Person p2("jerry", );
     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("啊呀呀", );
 }

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", );;
     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", );
     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", );
     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", );
     printPerson(p);
 }