C++ Study Notes 5

->
模板/框架
不是万能的

c++另一种编程思想为泛型编程,主要利用的技术就是模板
c++提供两种模板机制,函数模板和类模板

函数模板:
    建立一个通用函数,其函数返回值类型和形参类型可以不具体确定,用一个虚拟的类型来代表

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

    template    声明创建模板
    typename    表明其后面的符号是一种数据类型,可以用class代替

    template<typename T>
    void mySwap(T &a,T &b)
    {
        T tmp=b;
        b=a;
        a=tmp;
    }

    int a=1;
    int b=2;

    两种使用方式:
        1.自动类型推导      mySwap(a,b);
            必须推导出一致的类型才能使用
        2.显示指定类型      mySwap<int>(a,b);
            必须确定T的数据类型才能使用
        
普通函数可以发生隐式类型转换(自动类型转换)
函数模板调用时,如果利用自动类型推导,不会发生隐式类型转换
如果用显示指定类型方式,可以发生隐式类型转换

attention:
    1. 如果函数模板和普通函数都可以实现,优先调用普通函数       
            允许普通函数和函数模板同时存在,如果普通函数只有声明而没有实现,会报错
    2. 可以通过空模板参数列表来强制调用函数模板
            mySwap<>(a,b);          //尖括号里为空
    3. 函数模板也能重载
    4. 如果函数模板能够产生更好的匹配,优先调用函数模板
            模板推导比普通函数的自动类型转换更匹配

->
模板的局限性
template<typename T>
void f(T a,T b)
{
    a=b;
}

如果这个时候传入的参数为数组,就会出问题了
如果是自定义的数据类型,也有可能无法实现加减乘除、逻辑运算

为了解决这种问题,提供模板的重载,可以为这些特定的类型提供具体化的模板
template<class T>
bool myCompare(T &a,T &b)
{
    if (a==b)
    {
        return true;
    }
    else
    {
        return false;
    }
}

//重载
template<> bool myCompare(Person &p1,Person &p2)
{
    //具体的比较方式
}

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

->
类模板:
    template<class T>
    定义

建立一个通用类,类中的成员数据类型可以不具体制定,用一个虚拟的类型来代表
template<class NameType,class AgeType>
class Person
{
public:
    NameType m_name;
    AgeType m_age;
    Person(NameType name,AgeType age)
    {
        this->m_age=age;
        this->m_name=name;
    }
};

Person<string,int> p1("Tony",21);
Person<string,int> p2("Jenny",20);

类模板和函数模板的区别:
1.类模板没有自动类型推导使用方式,只能用显示指定类型
2.类模板在模板参数列表可以有默认参数

template<class NameType,class AgeType=int>
class Person
{...};


->
类模板中成员函数的创建时机:
    普通类中的成员函数一开始就可以创建
    类模板中的成员函数在调用时才创建            //调用的时候确定类型,确定了才创建

->
类模版对象做函数参数
三种方式:
    Person<string,int>p("name",9);
    1.指定传入的类型    直接显示对象的数据类型
        void printPerson1(Person<string,int> & p)

    2.参数模板化       将对象中的参数变为模板进行传递
        template<typename T1,typename T2>
        void printPerson2(Person<T1,T2>&p)

    3.整个类模板化      将这个对象类型,模板化进行传递
        template<class T>
        void printPerson3(T &p)         //让编译器自动推导类型
    
->
类模板与继承
当子类继承的父类是一个类模板的时候,子类在声明的时候,要指定出父类中T的类型
如果不指定,编译器无法给子类分配内存,因为不知道数据类型

template<typename T>
class Base
{
public:
    T m;
};

class Son:public Base<int>              //尖括号没指定类型会报错,不能是T,T会报错
{};

如果想要灵活指定出父类中T的类型,子类也需变为类模板
template<typename T1,typename T2>
class Son:public Base<T1>
{
    T2 obj;
};

->
类模板成员函数类外实现

template<class T1,class T2>
class Person
{
public:
    T1 m_name;
    T2 m_age;
    Person(T1 name,T2 age);
    void show();
};

template<class T1,class T2>                 //也要声明这是个模板,不然编译器不认识
Person<T1,T2>::Person(T1 name,T2 age)       //模板的参数列表也要加上去
{
    this->m_age=age;
    this->m_name=m_name;
}

template<class T1,class T2>
void Person<T1,T2>::show()                  //告诉编译器这是类模板中的成员函数
{
    cout<<this->m_name<<" ,"<<this->m_age<<endl;
}

->
类模板分文件编写
类模板中的成员函数在调用的时候才创建,导致分文件编写时链接不到
解决:
    1. 直接包含.cpp文件
    2. 将声明和实现写到同一个文件中,并更改后缀名为.hpp,hpp是约定的名称,不是强制
        .hpp约定俗称,.hpp就是类模板
    
->
类模板和友元
全局函数类内实现-直接在类内声明友元
全局函数类外实现-提前让编译器知道全局函数的存在

类外实现很复杂,类内实现就行了

类外实现:
-------------------------------------
template<class T1,class T2>
class Person;

template<class T1,class T2>
void printPerson2(Person<T1,T2> &p)
{
    cout<<p.m_name<<" ,"<<p.m_age<<endl;
}
-------------------------------------

template<class T1,class T2>
class Person
{
    //全局函数类内实现
    friend void printPerson(Person<T1,T2> &p)
    {
        cout<<p.m_name<<" ,"<<p.m_age<<endl;
    }

    // 全局函数类外实现
    // 加空模板参数列表
    // 如果全局函数是类外实现,需要让编译器提前知道
    friend void printPerson2<>(Person<T1,T2> &p);
private:
    T1 m_name;
    T2 m_age;
public:
    Person(T1 name,T2 age)
    {
        this->m_name=name;
        this->m_age=age;
    }
};