跟我一起透彻理解template模板模式

#include <iostream>
using namespace std;
//template模式。

class Base
{
public:
    void DealWhat()
    {
        this->Printf1();
        this->Printf2();
    }
protected:
    virtual void Printf1() = 0;
    virtual void Printf2() = 0;//让子类实现算法的详细实现。
};

class Son1 : public Base
{
public:
    void Printf1()
    {
        cout << "Son1::Printf1()" << endl;
    }
    void Printf2()
    {
        cout << "Son1::Printf2()" << endl;
    }
};

class Son2 : public Base
{
public:
    void Printf1()
    {
        cout << "Son2::Printf1()" << endl;
    }
    void Printf2()
    {
        cout << "Son2::Printf2()" << endl;
    }
};

int main()
{
    Base *b = new Son2();
    b->DealWhat();
    return 0;
}

感悟：

基类的方法由不同子类去详细实现，我们须要什么详细的算法

或者算法，直接构造相关的子类就能够使用，可是公共接口还

是定义在基类中，这样方便全部的子类都能够利用C++多态机制进行覆盖改写。

以下是我的详细事例详细解释：

#include <iostream>
using namespace std;
//template模式。

class Base
{
public:
    Base(int a[],int n)
    {
        data = new int[n];
        int i = 0;
        for (; i < n; i++)
        {
            data[i] = a[i];
        }
        size = n;
    }
    void Printf()
    {
        int i = 0;
        for (; i < size; i++)
        {
            cout << data[i] << " ";
        }
        cout << endl;
    }
    void DoWhat()
    {
        this->sort();
        //算法的详细实现交给不同的子类来实现，我们通过共同拥有的接口来调用。

}
protected:
    virtual void sort() = 0;//排序方法的实现。
    int *data;
    int size;
};
class Bubble : public Base//冒泡排序。

{
public:
    Bubble(int a[], int n) :Base(a, n){}
    void sort()
    {
        int i = 0;
        int temp;
        for (; i < size; i++)
        {
            for (int j = 0; j<(size-i-1); j++)
            {
                if (data[j+1]<data[j])
                {
                    temp = data[j];
                    data[j] = data[j+1];
                    data[j+1] = temp;
                }
            }
        }
    }
};
class Insert : public Base//插入排序。

{
public:
    Insert(int a[], int n) :Base(a, n){}
    void sort()
    {
        int i = 0;
        int j;
        int k;
        int temp;
        for (; i < size; i++)
        {
            j = i;
            temp = data[i];
            for (k = 0; k <= i; k++)
            {
                if (data[k]>temp)
                {
                    break;
                }
            }
            for (; j > k; j--)
            {
                data[j] = data[j - 1];
            }
            data[j] = temp;
        }
    }
};
class Qulick : public Base//高速排序。
{
public:
    Qulick(int a[], int n) :Base(a, n){}
    void sort()
    {
        sort(data,0,size);
    }
private:
    void sort(int a[], int low, int high)
    {
        int i = -1;
        int j = 0;
        if ( low>=high )return;
        int key = data[high-1];
        int temp;
        while (j<high)
        {
            while (data[j]>key)j++;
            i++;
            temp = data[i];
            data[i] = data[j];
            data[j] = temp;
            j++;
        }
        data[i] = key;
        sort(a,0,i-1);
        sort(a,i+1,high);
    }
};
class Select : public Base//选择排序。
{
public:
    Select(int a[], int n) :Base(a, n){}
    void sort()
    {
        int i = 0;
        int j;
        int temp;
        for (; i < size - 1; i++)
        {
            for (j = i + 1; j < size; j++)
            {
                if (data[i]>data[j])
                {
                    temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                }
            }
        }
    }
};

int main()
{
    int a[] = { 4, 6, 7, 9, 1, 23, 4 };
    /*Base *p = new Qulick(a, 7);
    p->DoWhat();
    p->Printf();//插入排序。

*/
    Base *p = new Bubble(a,7);
    p->DoWhat();
    p->Printf();//冒泡排序。

return 0;
}