文章目录
- 1. 理论基础
- 2. 逻辑代码
- 3. 应用
- 3.1 做汉堡咯
思考:
为何肯德基麦当劳这些快餐能在中国这个上下五千年的国都站住脚? 中国的鱼香肉丝为何不能成为令人追捧的快餐?
因为麦当劳肯德基使用的是统一制造的快餐, 也就相当于厨师是一个厨师, 而中国的饭店每个都有鱼香肉丝, 但是中国的饭店每个店的厨师都不相同, 鱼香肉丝的味道也各不相同, 正是因为这样的差别, 我们不确定未吃过的店里面的鱼香肉丝是否使我们想吃的, 而肯德基我们不管在哪家店, 吃的汉堡都是一个味道的, 只要喜欢吃, 任意哪家的都可以吃;
因此鱼香肉丝依赖于厨师, 想想设计模式的原则?
依赖倒转原则: 抽象不应该依赖细节, 但是细节应该依赖抽象, 这样做的结果就是很被动; 而肯德基可以的工作流程相当于抽象流程(放料,烧烤,摸辣等), 具体放什么配料, 烤多长时间等细节都是依赖于这个抽象;
本文还涉及到两个知识点
-
delete在本文之前,我的delete都是使用的delete p1, p2, p3这样的格式, 但是这样做是错误的, 因为上面的语句表达的是: delete p1; p2; p3, 因此只删除了p1; 此外在C++中, 由于编译器不负责delete p1这样的指针, 因此当delete执行完毕后, 只回收了p1指向的堆内存空间, 但是p1这个指针依然真实存在的, 此时p1已经成为了野指针, 因此delete p1后, 还需要把p1删除, 删除的格式是 p1 = nullptr, 这样后面就无法在访问这个p1的指针了 -
析构函数当子类继承基类, 子类中会生成指针对象, 并且要在子类析构时回收这个对象, 那么必须要在基类的析构函数定义为虚函数, 这样一旦有多态的情况就可以对子类里面的指针对象进行回收了.
class A{
public:
virtual ~A(){} // 命令1
virtual void getName(){};
};
class B : public A{
private:
string name;
public:
A * a = new A();
B(string n): name(n){}
~B(){ // 如果命令1被注释掉, 这里是不会运行的
delete a; a = nullptr;
cout << "析构" << name <<endl;
}
void getName(){
cout<< "name = "<< name <<endl;
}
};
int main(int argc, char const *argv[])
{
A * b1 = new B("b1");
A * b2 = new B("b2");
A * b3 = new B("b3");
A * b4 = new B("b4");
delete b1,b2,b3,b4;
// b1->getName(); // 但这里还是可以编译成功 但是运行失败Segmentation fault (core dumped)
b1 = nullptr;
if(b1){
cout << "b1 不空, 可以使用" <<endl;
b1->getName();
}
cout << "这里才是正经的删除不同的指针对象" <<endl;
delete b2, delete b3, delete b4; b2=b3=b4=nullptr;
return 0;
}1. 理论基础
目的：
将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
主要解决：
主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
何时使用：
一些基本部件不会变，而其组合经常变化的时候。
如何解决：
将变与不变分离开。
关键代码：
建造者：创建和提供实例，
导演：管理建造出来的实例的依赖关系。
应用实例：
1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。
2、JAVA 中的 StringBuilder。
优点：
1、建造者独立，易扩展。 2、便于控制细节风险。
缺点：
1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。
使用场景：
1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。
注意事项：
与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。
2. 逻辑代码
如上图所示:
-
Builder相当于制作汉堡的抽象类, 为Product对象的各个部件指定的抽象接口 -
ConcreteBuilder相当于具体实现制作汉堡的各个细节流程 -
Director指挥者, 根据用户需要构建不同的汉堡 -
什么时候需要使用到建造者模式呢? 用于创建一些复杂对象, 这些对象内部构建间的构造顺序通常是稳定的, 但对象内部的构建通常面临着复杂的变化
#include <iostream>
#include <algorithm>
#include <string.h>
#include <list>
using namespace std;
// 产品类
class Product{
private:
list<string> parts; // 使用链表创建部件
public:
virtual ~Product(){}
// 添加产品部件
void Add(string part){
parts.push_back(part);
}
void Show(){
cout<< "产品创建 ... " <<endl;
for(auto &s : parts){
cout << s <<endl;
}
}
};
// Builder类
class Builder{
public:
virtual ~Builder(){}
virtual void BuildPartA() = 0;
virtual void BuildPartB() = 0;
virtual Product *GetResult() = 0;
};
// 具体建造者类
// 建造者1
class ConcreteBuilder1 : public Builder{
private:
Product *product = new Product();
public:
~ConcreteBuilder1(){
cout << "jjjj" <<endl;
try {
delete product; product = nullptr;
}
catch(const std::exception& e) {
std::cerr << e.what() << '\n';
}
}
void BuildPartA(){
product->Add("部件 A");
}
void BuildPartB(){
product->Add("部件 B");
}
Product* GetResult(){
return product;
}
};
// 建造者2
class ConcreteBuilder2 : public Builder{
private:
Product *product = new Product();
public:
~ConcreteBuilder2(){
cout << "删除成功?? " <<endl;
delete product; product = nullptr;
}
void BuildPartA(){
product->Add("部件 X");
}
void BuildPartB(){
product->Add("部件 Y");
}
Product* GetResult(){
return product;
}
};
// 指挥者 Director类
class Director{
public:
~Director(){
cout << "delete Direct" <<endl;
}
void Construct(Builder *builder){
builder->BuildPartA();
builder->BuildPartB();
}
};
int main(int argc, char const *argv[])
{
Builder *b1 = new ConcreteBuilder1();
Builder *b2 = new ConcreteBuilder2();
Director *director = new Director();
director->Construct(b1);
Product *p1 = b1->GetResult();
p1->Show();
director->Construct(b2);
Product *p2 = b2->GetResult();
p2->Show();
delete b1; b1 = nullptr;
delete b2; b2 = nullptr;
delete director; director = nullptr;
// 下面这俩会报错, 因为已经在上面b1和b2析构了
// delete p1; p1 = nullptr;
// delete p2; p2 = nullptr;
// 注意这里的Builder类的析构函数必须定义成virtual, 不然就无法删除子类实例
return 0;
}
3. 应用
3.1 做汉堡咯
三层
产品
建造者
指挥者
客户
// 产品类
class Product{
private:
list<string> parts; // 使用链表创建部件
public:
virtual ~Product(){}
// 添加产品部件
void Add(string part){
parts.push_back(part);
}
void Show(){
cout<< "产品创建 ... " <<endl;
for(auto &s : parts){
cout << s <<endl;
}
}
};
// Builder类
class Builder{
public:
virtual ~Builder(){}
virtual void BuildPartA() = 0;
virtual void BuildPartB() = 0;
virtual void BuildPartC() = 0;
virtual Product *GetResult() = 0;
};
// 具体建造者类
// 烧鸡建造
class ConcreteBuilderSJ : public Builder{
private:
Product *product = new Product();
public:
~ConcreteBuilder1(){
delete product; product = nullptr;
}
void BuildPartA(){
product->Add("油炸10小时");
}
void BuildPartB(){
product->Add("咸盐20斤");
}
void BuildPartC(){
product->Add("芥末1kg");
}
Product* GetResult(){
return product;
}
};
// 建造者 芥末鸡
class ConcreteBuilderJMJ : public Builder{
private:
Product *product = new Product();
public:
~ConcreteBuilder2(){
cout << "删除成功?? " <<endl;
delete product; product = nullptr;
}
void BuildPartA(){
product->Add("油炸1小时");
}
void BuildPartB(){
product->Add("咸盐2斤");
}
void BuildPartC(){
product->Add("芥末100吨");
}
Product* GetResult(){
return product;
}
};
// 指挥者 Director类
class Director{
public:
~Director(){
cout << "delete Direct" <<endl;
}
void Construct(Builder *builder){
builder->BuildPartA();
builder->BuildPartB();
builder->BuildPartC();
}
};
int main(int argc, char const *argv[])
{
Builder *b1 = new ConcreteBuilderSJ(); // 烧鸡厨师
Builder *b2 = new ConcreteBuilderJMJ(); // 芥末鸡厨师
Director *director = new Director(); // 后厨老大
director->Construct(b1); // 老大要求烧鸡厨师创建个烧鸡
Product *p1 = b1->GetResult();// 烧鸡厨师产出一个烧鸡
p1->Show(); // 烧鸡给顾客
director->Construct(b2);
Product *p2 = b2->GetResult();
p2->Show();
delete b1; b1 = nullptr;
delete b2; b2 = nullptr;
delete director; director = nullptr;
return 0;
}
