C++知识点随笔(六)：模板

一、函数模板

C++中模板和重载的区别：
模板是除了类型全都相同的情况下可以使用；而重载是里面的功能也有不同时使用的。
下面看一个函数模板的使用实例：

#include<iostream>
using namespace std;

typedef struct _Node
{
    int m_a;
    char* m_str;
}Node;

bool leftNodeBig(Node a, Node b) //结构体从大到小排
{
    return (a.m_a < b.m_a);
}

template <typename T>   //整形从大到小排
bool leftBig(T t, T w)
{
    return (t < w); 
}

template <typename T>   //整形从小到大排
bool leftSmall(T t, T w)
{
    return (t > w); 
}

template <typename T>
void Bubble(T* arr, int nLength, bool (*pFun)(T a, T b)) //注意函数指针格式
{
    for(int i=0;i<nLength-1;i++)
    {
        for (int j=0;j<nLength-1-i;j++)
        {
            if((*pFun)(arr[j], arr[j+1]))
            {
                //注意这里不能通过 ^ 交换了，因为结构体无法这样交换
                //arr[j] = arr[j] ^ arr[j+1]; 
                //arr[j+1] = arr[j] ^ arr[j+1];
                //arr[j] = arr[j] ^ arr[j+1];
                T temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

template <typename T>
void Show(T* arr, int nLength)
{
    for(int i=0;i<nLength;i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}

ostream& operator<<(ostream& os, Node& node) //重载操作符保证结构体正常输出
{
    os << node.m_a << " " << node.m_str;
    return os;
}


int main()
{
    int arr[] = {1,3,5,7,9,0,8,6,4,2};
    Bubble(arr, 10, &leftBig<int>);
    Show(arr, 10);

    char str[] = {'b','e','f','y','s','a','c','d','l','z'};
    Bubble(str, 10, &leftSmall<char>);
    Show(str, 10);

    Node arrNode[] = {{10,"hehe"},{9,"haha"},{100,"yaya"}};
    Bubble(arrNode, 3, &leftNodeBig);
    Show(arrNode,3);

    system("pause");
    return 0;
}

二、类模板

类模板要注意：只要我们定义了类模板的 template，那么我们只要除了这个类，一见到这个类名，就要加：

CPeople<>

其实函数模板也是一样的，定义了函数模板之后，我们在外面使用这个函数的时候也要添加类型，不加同样会报错，就像我们上面写的：

Bubble(arr, 10, &leftBig<int>);

下面我们看一段类模板的使用实例：

#include<iostream>
using namespace std;

template<typename T>
class CPeople
{
public:
    //注意使用初始列表给成员变量初始化，因为我们传进来的模板T有可能是对象，前面我们也学习过，如果在类中定义一个有参数的类，那么一定要在初始化列表中给它传参。
    CPeople(T t):m_t(t) 
    {
    }
    virtual void Show() //虚函数，调用子类重写的 Show()
    {
        cout << this->m_t << endl;
    }
protected:
    T m_t;
};

template<typename P, typename Q>
class CChinese : public CPeople<Q>
{
public:
    CChinese(P p, Q q):CPeople<Q>(q), m_p(p) //这里一定要使用初始化列表
    {
    }
    void Show()
    {
        //如果我们不重载CAA类的‘<<’操作符的话，这一句就会报错
        cout << m_t << " " << this->m_p << endl;
    }
private:
    P m_p;
};

template<typename M>
class CAA
{
public:
    CAA(M m)
    {
        this->m_m = m;
    }
public：
    M m_m;
};

template<typename N>
ostream& operator<<(ostream& os, CAA<N>& aa)  //重载CAA类的操作符
{
    os << aa.m_m;
    return os;
}

int main()
{
    //父类指针指向子类对象，子类实现<double, char*>类型的模板
    CPeople<char*> *p1 = new CChinese<double, char*>(123.456, "hello");
    p1->Show();

    //父类指针指向子类对象，子类将对象作为模板
    CAA<double> caa(56.78);
    CPeople<CAA<double>> *p2 = new CChinese<double, CAA<double>>(123.456, caa);
    p2->Show();

    //父类指针指向子类对象，子类将两个对象作为模板
    CAA<char*> *cbb = new CAA<char*>("hello world!");
    CPeople<CAA<char*>> *p3 = new CChinese<CAA<double>,CAA<char*>>(caa, *cbb);
    p3->Show();

    system("pause");
    return 0;
}