模板方法、策略和职责链模式（行为型设计模式）的 C++ 代码示例模板。
结构
代码
#include <iostream>
using std::cout;
using std::endl;
// 抽象类
class Abstraction
{
public:
// 抽象类 定义 模板方法
void template_method() // 形式上 调用 模板方法
{
cout << "template_method()" << endl;
// 实际上 调用 步骤方法。即 哪些 步骤方法 何时 调用（规定组合内容和执行时序） （抽象的模板，不变行为）
step_func_1();
step_func_2();
}
protected:
// 抽象类 声明 步骤方法（零个或多个）（由派生类重写/实现）
// 步骤方法1
virtual void step_func_1() = 0;
// 步骤方法2
virtual void step_func_2() = 0;
};
// 具体1类
// 具体类（零个或多个） 重写/实现 步骤方法 （具体的步骤，变化行为）
class Concreteness1 : public Abstraction
{
protected:
void step_func_1() override
{
cout << "Concreteness1 - step_func_1()" << endl;
}
void step_func_2() override
{
cout << "Concreteness1 - step_func_2()" << endl;
}
};
// 具体1类
class Concreteness2 : public Abstraction
{
protected:
void step_func_1() override
{
cout << "Concreteness2 - step_func_1()" << endl;
}
void step_func_2() override
{
cout << "Concreteness2 - step_func_2()" << endl;
}
};
// 客户端
int main()
{
// 抽象类指针（实际上指向一个具体类）
Abstraction *abstraction_1 = new Concreteness1();
abstraction_1->template_method(); // 抽象类指针（实际上指向一个具体类） 调用 抽象类/父类的模板方法 就是一个方案
delete abstraction_1;
cout << endl;
Abstraction *abstraction_2 = new Concreteness2();
abstraction_2->template_method();
delete abstraction_2;
return 0;
}
/*
输出：
template_method()
Concreteness1 - step_func_1()
Concreteness1 - step_func_2()
template_method()
Concreteness2 - step_func_1()
Concreteness2 - step_func_2()
*/
结构
代码
#include <iostream>
using std::cout;
using std::endl;
// 抽象策略类
class AbstractStrategy
{
public:
virtual void execute() = 0;
};
// 具体策略1类
class ConcreteStrategy1 : public AbstractStrategy
{
public:
void execute() override
{
cout << "ConcreteStrategy1" << endl;
}
};
// 具体策略2类
class ConcreteStrategy2 : public AbstractStrategy
{
public:
void execute() override
{
cout << "ConcreteStrategy2" << endl;
}
};
// 上下文类
// 上下文类 封装 抽象策略指针（实际上指向一个具体策略对象）
class Context
{
public:
Context(AbstractStrategy *strategy) : strategy(strategy) {}
// 设置策略方法
void set_strategy(AbstractStrategy *strategy)
{
this->strategy = strategy;
}
// 执行策略方法
void execute_strategy() // 形式上调用 上下文对象的 执行策略方法
{
this->strategy->execute(); // 实际上调用 具体策略对象的 执行方法
}
private:
AbstractStrategy *strategy;
};
// 客户端
int main()
{
// 具体策略对象
ConcreteStrategy1 concrete_strategy_1;
ConcreteStrategy2 concrete_strategy_2;
// 上下文对象
Context context(&concrete_strategy_1); // 设置策略
context.execute_strategy(); // 执行策略
context.set_strategy(&concrete_strategy_2); // 设置策略
context.execute_strategy();
return 0;
}
/*
输出：
ConcreteStrategy1
ConcreteStrategy2
*/
结构
代码
#include <iostream>
using std::cout;
using std::endl;
// 请求类
class Request
{
public:
Request(int type) : type(type) {}
// 获取请求的类型
int get_type()
{
return this->type;
}
private:
int type; // 请求的类型
};
// 抽象处理者类
class AbstractHandler
{
public:
virtual ~AbstractHandler()
{
delete this->successor;
}
// 设置继任者方法
void set_successor(AbstractHandler *successor)
{
this->successor = successor;
}
// 处理请求方法
virtual void handle_request(Request request)
{
if (this->successor != nullptr) // 如果有继任者，继任者 调用 处理请求方法处理请求
{
this->successor->handle_request(request);
}
else // 如果没有继任者，无法处理请求
{
cout << "Request not handled" << endl;
}
}
protected:
// 抽象处理者类 封装 抽象处理者指针（实际上指向一个具体处理者对象，该对象是当前具体处理对象的下一个具体处理对象/下一个处理者/继任者）
AbstractHandler *successor = nullptr; // 默认没有继任者
};
// 具体处理者1类
// 具体处理者类 重写 处理请求方法
class ConcreteHandler1 : public AbstractHandler
{
public:
void handle_request(Request request) override
{
// 获取并判断请求的类型
if (request.get_type() == 1) // 如果有权处理请求，当前具体处理对象处理请求
{
cout << "ConcreteHandler1 handles the request" << endl;
}
else // 如果无权处理请求，调用基类/抽象处理者类的处理请求方法（将请求交给继任者处理）
{
AbstractHandler::handle_request(request);
}
}
};
// 具体处理者2
class ConcreteHandler2 : public AbstractHandler
{
public:
void handle_request(Request request) override
{
if (request.get_type() == 2)
{
cout << "ConcreteHandler2 handles the request" << endl;
}
else
{
AbstractHandler::handle_request(request);
}
}
};
// 客户端
int main()
{
// 抽象处理者指针（实际上指向一个具体处理者对象）
AbstractHandler *concrete_handler_1 = new ConcreteHandler1();
AbstractHandler *concrete_handler_2 = new ConcreteHandler2();
// 设置处理者链：concrete_handler_1 -> concrete_handler_2
concrete_handler_1->set_successor(concrete_handler_2);
// 请求对象
Request request_1(1); // 1类型的请求
Request request_2(2);
Request request_3(3);
// 处理请求
concrete_handler_1->handle_request(request_1);
concrete_handler_1->handle_request(request_2);
concrete_handler_1->handle_request(request_3);
// 1类型的请求，具体处理1对象有权处理
// 2类型的请求，具体处理1对象无权处理，将请求交给继任者处理；具体处理2对象有权处理
// 3类型的请求，具体处理1对象无权处理，将请求交给继任者处理；具体处理2对象无权处理，没有继任者；无法处理请求
delete concrete_handler_1; // 递归析构 delete concrete_handler_2
return 0;
}
/*
输出：
ConcreteHandler1 handles the request
ConcreteHandler2 handles the request
Request not handled
*/
模板方法、策略和职责链模式（行为型设计模式）的 C++ 代码示例模板。