[软件开发]C++设计模式_组件协作模式_Template Method 模板方法

一、23种设计模式的分类方法：

1、从目的角度分为创建型模式、结构型模式、行为型模式；

2、从范围角度分为类模式（继承方案）和对象模式（组合方案）

二、好的面向对象设计：应对变化，提高复用

三、重构的关键技术法则

四、组件协作模式包括：Template Method, Stratety, Observer / Event（模板方法，策略模式，事件模式）

五、模板方法

1、动机（发生场景）：对某项任务，存在稳定的整体操作骨架，但是各个子步骤有改变需求、或者无法同时实现

2、问题：在稳定结构下灵活应对变化和晚期需求

3、代码

（1）基类的析构函数应该是虚函数形式：virtual ~className(){ } 这样在delete new对象的时候，才能调到子类的析构函数

例如上图，声明是基类型指针，实际对象是子类，那么在delete时候是需要析构子类的，这时候，原基类的析构函数应为 virtual

（2）非模板方法与模板方法对比

非模板方法：

 模板方法：

（3）模板方法要点：

A.在模板方法中，将程序流程放到Library人员将模板完成，再由APP开发人员去继承Library并实现虚函数

B.这样app开发人员工作量降低。并且实现了晚绑定的机制（lib写的早，app写的晚，由lib调用app，是早调用晚）

C.定义一个算法稳定骨架(run方法)，将一些步骤延迟到子类（定义一些虚函数，让子类去实现），其实这就是支持子类去变化，满足了开放封闭原则，使得子类可以不改变（即为复用）一个算法的结构，同时可以修改这些虚函数的实现。

D.稳定中（run方法）有变化（子类实现虚函数）

E.稳定的代码（run方法）要写成非虚函数

F.使用模板方法的前提是，run()方法调用流程是稳定的，即稳定的算法骨架。

4、设计模式最大的作用：在稳定和不稳定部分划分开来，处理不稳定部分。

5、总结

• 模板方法模式是一种基础性的模式，很常用。它用最简洁的机制（虚函数的多态性）提供了稳定的框架和灵活的扩展点，是代码复用方面的基本实现结构。（扩展=继承+父类虚函数实现）
• 除了应对子步骤的变化之外，模板方法模式的典型应用是反向控制结构（晚绑定，父类写出run并调用虚函数，让子类去实现虚函数）
• 具体实现方面，父类的这几个虚函数，可以没有实现（纯虚函数），也可以有实现，但一般都置为protected方法（因为这几个方法作为public被单独调用是没有意义的）

附加：虚函数，纯虚函数，指针等问题

1、虚函数、纯虚函数、普通函数的不同之处

• 虚函数主要作用是“运行时多态”，父类中提供虚函数的实现，为子类提供默认的函数实现。（即父类给出第一种实现，子类可以重写）

virtual void out2(string s)
    {
        cout<<"A(out2):"<<s<<endl;
    }

• 包含纯虚函数的类，被称为是“抽象类”。抽象类不能使用new出对象，只有实现了这个纯虚函数的子类才能new出对象。

class A //由于纯虚函数的存在，A为抽象类，无法new出对象
{
public:
    virtual void out1(string s)=0; //纯虚函数
    virtual void out2(string s)
    {
        cout<<"A(out2):"<<s<<endl;
    }
};

• 纯虚函数“只提供申明，没有实现”，是对子类的约束，是“接口继承”。
• （另）普通函数是静态编译的，没有运行时多态，只会根据指针或引用的“字面值”类对象，调用自己的普通函数。
• 普通函数是父类为子类提供的“强制实现”。因此，在继承关系中，子类不应该重写父类的普通函数。

#include <iostream>
using namespace std;

class A
{
public:
    virtual void out1()=0; //由子类实现：纯虚函数由子类实现
    virtual ~A(){};
    virtual void out2() //默认实现：子类可以重写函数。虚函数是为了允许用基类的指针来调用子类的函数
    {
        cout<<"A(out2)"<<endl;
    }
    void out3() //强制实现：子类不应该重写函数
    {
        cout<<"A(out3)"<<endl;
    }
};

class B:public A
{
public:
    virtual ~B(){};
    void out1()
    {
        cout<<"B(out1)"<<endl;
    }
    void out2()
    {
        cout<<"B(out2)"<<endl;
    }
    void out3()
    {
        cout<<"B(out3)"<<endl;
    }
    //自己添加的
    void out4()//子类中可以有父类没有的函数
    {
        cout<<"B(out4)"<<endl;
    }
};

2、类对象指针

• 类对象：Student s1      类对象指针：Student *s2
• 定义对象实例时，分配了内存，指针变量则未分配类对象所需内存。
• 类的指针:他是一个内存地址值,他指向内存中存放的类对象(包括一些成员变量所赋的值).   
• 指针变量是间接访问，但可实现多态（通过声明父类指针可调用或者new一个子类对象），new之前没有调用构造函数。
• 直接声明可直接访问，但不能实现多态，声明即调用了构造函数（已分配了内存）。 
• 对象用的是栈内存,是个局部的临时变量；指针用的是堆内存,是个永久变量,除非你释放它，需要手动delete
• 类指针的优点：1 实现多态 2 在函数调用，传指针参数。不管你的对象或结构参数多么庞大，你用指针，传过去的就是4个字节。如果用对象，参数传递占用的资源就太大了

3、将类对象指针作为函数参数、格式

//使用类对象指针作为函数参数

class M{
public:
  M() { x=y=0; }
  M(int i, int j) { x=i; y=j; }

  void copy(M *m);
  void setxy(int i, int j) { x=i; y=j; }
  void print() { cout<<x<<","<<y<<endl; }

private:
  int x, y;
};
 
void M::copy(M *m){
  x=m->x;
  y=m->y;
}

void fun(M m1, M *m2){     //实现将类对象指针作为参数传递，相当于传引用
    m1.setxy(12, 15);
    m2->setxy(22,25);
}

4、用new创建对象和不用new的区别

• new创建类对象，使用完后需使用delete删除。
• new创建类对象需要指针接收，一处初始化，多处使用
• new创建对象直接使用堆空间，而局部不用new定义类对象则使用栈空间
• new对象指针用途广泛，比如作为函数返回值、函数参数等

// new 和对象指针的实例

/* 1.new申请的对象，则只有调用到delete时再会执行析构函数，如果程序退出而没有执行delete则会造成内存泄漏。 */

CTest* pTest = new CTest();
delete pTest;

/* 2.new申请对象为经过初始化，不需要delete */

CTest* pTest = NULL;

/* 3.new对象指针作为函数参数和返回值实例 */


class test1{

public:
    int a;
};

class test2{

public:
    int b;
};

test1* function(test2* test2_){//形参是类2对象的指针
    test1* test1_ = new test1();
    test1_->a = test2_->b;
    return test1_; //返回类1的指针
}

int main(){
    test2* test2_ = new test2();
    test1* test1_ = function(test2_);


    if(test2_ != NULL) delete test2_;
    if(test1_ != NULL) delete test1_;

    return 0;
}