C++函数模版/类模版

**函数模版**

    C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板 
    C++提供两种模板机制: 函数模板和类模
    
函数模版的声明或使用：
    template 或者 template 一个主要用于普通函数模版，一个是类模版
    都用class都没有错。
    
    解释：
        template --- 声明创建模板 
        typename --- 表面其后面的符号是一种数据类型，可以用class代替
        T --- 通用的数据类型，名称可以替换，通常为大写字母     
    
示例：
//利用模板提供通用的交换函数 
template 
void mySwap(T& a, T& b) 
{    
    T temp = a;    
    a = b;    
    b = temp; 
}

注意及作用：
        1. 函数模板利用关键字 template 
        2. 使用函数模板有两种方式：自动类型推导、显示指定类型 
            1. 自动类型推导，必须推导出一致的数据类型T,才可以使用 
            2. 模板必须要确定出T的数据类型，才可以使用

        3.模板的目的是为了提高复用性，将类型参数化

 

 

 

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

1. 普通函数调用时可以发生自动类型转换（隐式类型转换） 
2. 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换 
3. 如果利用显示指定类型的方式，可以发生隐式类型转换


//函数模板 template 
T myAdd02(T a, T b)  
{    
    return a + b; 
}
 

//使用函数模板时，如果用自动类型推导，不会发生自动类型转换,即隐式类型转换 
void test01() 
{    
    int a = 10;    
    int b = 20;    
    char c = 'c';        
    cout << myAdd01(a, c) << endl; //正确，将char类型的'c'隐式转换为int类型  'c' 对应 ASCII码 99
 
    //myAdd02(a, c); // 报错，使用自动类型推导时，不会发生隐式类型转换
 
    myAdd02(a, c); //正确，如果用显示指定类型，可以发生隐式类型转换 
}
 
总结：建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

 

 

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

1. 如果函数模板和普通函数都可以实现，优先调用普通函数 
2. 可以通过空模板参数列表来强制调用函数模板 
        myPrint<>(a, b); //调用函数模板
3. 函数模板也可以发生重载 
    template 
        void myPrint(T a, T b) 

    template 
        void myPrint(T a, T b, T c)
4. 如果函数模板可以产生更好的匹配,优先调用函数模板

 总结：既然提供了函数模板，好就不要提供普通函数，否则容易出现二义性
   

** 模板的局限性 **

template    
void f(T a, T b)    
{         
    a = b;    
}
    如果传入的a和b是一个数组，就无法实现了
    如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供**具体化的模板**


//具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型 
//具体化优先于常规模板 

template<> bool myCompare(Person &p1, Person &p2) 
{    
    if ( p1.m_Name  == p2.m_Name && p1.m_Age == p2.m_Age)    
    {        
        return true;    
    }    
    else    
    {       
        return false;    
    } 
}

总结：
利用具体化的模板，可以解决自定义类型的通用化 
学习模板并不是为了写模板，而是在STL能够运用系统提供的模板
 

**类模版**

类模板作用：
建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表

定义或声明:
    template 
    class Person
    {};

示例：
//类模板 
template 
class Person 
{ 
    public:    
    Person(NameType name, AgeType age)    
    {        
        this->mName = name;        
        this->mAge = age;    
    }    
    void showPerson()    
    {        
        cout << "name: " << this->mName << " age: " << this->mAge << endl;    
    } 
public:    
    NameType mName;    
    AgeType mAge; 
};
 
void test01() 
{    
    //指定NameType 为string类型，AgeType 为 int类型    
    PersonP1("孙悟空", 999);    //使用
    P1.showPerson(); 
}
 

**类模板与函数模板区别 **

 
类模板与函数模板区别主要有两点：
1. 类模板没有自动类型推导的使用方式 
2. 类模板在模板参数列表中可以有默认参数
    template //可以有默认参数
    class Person 
    { };
 

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

 

类模板中成员函数和普通类中成员函数创建时机是有区别的：
1. 普通类中的成员函数一开始就可以创建 
2. 类模板中的成员函数在调用时才创建
    template class MyClass 
    { public:    
        T obj;
 
        //类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成
 
        void fun1() 
        { 
            obj.showPerson1(); 
        }    
        void fun2() 
        { 
            obj.showPerson2();
        }
 
};

void test01() 
{    
    MyClass m;       
     m.fun1();  
    //m.fun2();//编译会出错，说明函数调用才会去创建成员函数

    MyClass m ;
    m.fun2();//ok
}

 

**类模板对象做函数参数 **

类模版实例化对象，向函数传参的方式有三种：
1. 指定传入的类型       --- 直接显示对象的数据类型
    
    //1、传参， 指定传入的类型 （常用）
    void printPerson1(Person &p) 
    {
        p.showPerson(); 
    } 
    void test01() 
    {
        Person p("孙悟空", 100);   
         printPerson1(p); 
    }
 
 
2. 参数模板化        --- 将对象中的参数变为模板进行传递 
    
    //2、参数模板化 
    template  
    void printPerson2(Person&p) 
    {
        p.showPerson();
        cout << "T1的类型为： " << typeid(T1).name() << endl;
        cout << "T2的类型为： " << typeid(T2).name() << endl; 
    } 
    void test02() 
    {
        Person p("猪八戒", 90);
        printPerson2(p); 
    }
    

3. 整个类模板化          --- 将这个对象类型 模板化进行传递
//3、整个类模板化 
    template 
    void printPerson3(T & p)
    {
        cout << "T的类型为： " << typeid(T).name() << endl;   
        p.showPerson();
     
    } 
    void test03() 
    {    
        Person p("唐僧", 30);    
        printPerson3(p); 
    }

 

**类模板与继承 **

 

当类模板碰到继承时，需要注意一下几点：
    1. 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型 
    如果不指定，编译器无法给子类分配内存 
    

template class Base 
{    
    T m; 
};
 
class Son:public Base            //错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
{}

class Son :public Base    //正确，必须指定一个类型 
{}

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

//类模板继承类模板 ,可以用T2指定父类中的T类型 
template 
class Son2 :public Base 
{ 
    public:    
        Son2()    
        {        
            cout << typeid(T1).name() << endl;        
            cout << typeid(T2).name() << endl;    
        } 
};

 

 **类模板成员函数类外实现**

 //类模板中成员函数类外实现 
template 
class Person 
{ 
    public:    
    //成员函数类内声明    
        Person(T1 name, T2 age);    
        void showPerson();
     
    public:    
        T1 m_Name;    
        T2 m_Age; 
};

使用方法：

    //构造函数 类外实现 
        template 
        Person::Person(T1 name, T2 age) {}

    //成员函数 同理
        template 
        void Person::showPerson()     {}