十二种设计模式

鄠邑原野

已于 2024-02-21 23:16:27 修改

阅读量990

点赞数 27

分类专栏：设计模式文章标签：设计模式开发语言 c++

于 2024-02-21 23:14:33 首次发布

本文链接：https://blog.youkuaiyun.com/2301_81389826/article/details/136222196

版权

本文详细介绍了设计模式，包括工厂模式、单例模式、原型模式等十二种常见设计模式，探讨了它们的作用、应用场景及优缺点，旨在帮助开发者更好地理解和运用设计模式，提升软件设计的灵活性和可维护性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1 设计模式概述

作用：

面向对象系统的分析和设计实际上在追求两点：高内聚（Cohesion）和低耦合（Coupling）。因此，无论是封装、继承、多态还是设计模式都是为了这两个目标在努力。

设计模式体现的是一种思想，而思想是指导行为的一切，设计模式可以指导程序员设计和开发。

设计模式分类：

2 工厂模式

两个最重要的功能：

1）定义创建对象的接口，封装对象的创建；

2）使得具体化类的工作延迟到子类中。

应用：买车，不需要知道车是怎么造出来的、要哪个产品工厂给哪个产品，不需要知道产品怎么制造。

#include<stdio.h>
#include<iostream>
 
using namespace std;
 
class Product{
public:
	virtual void Do()=0;  //纯虚函数
	virtual ~Product()    //虚析构
        {
		cout<<"Product is destructed!"<<endl;
	}
};
 
class ProductA:public Product{   //公有继承，每个子类中都有Do成员方法
public:
	void Do(){
		cout<<"正在制造ProductA!"<<endl;
	}
};
 
class ProductB:public Product{  //公有继承
public:
	void Do(){
		cout<<"正在制造ProductB!"<<endl;
	}
};
 
class ProductC:public Product{  //公有继承
public:
	void Do(){
		cout<<"正在制造ProductC!"<<endl;
	}
};
 
class Factory{          //工厂类
private:
	Product *product;     //私有的工厂类指针
public:
	Factory(int n)        //Factory有参构造
        {
	     switch(n){       //switch-case语句确定构造哪个产品对象
                case1: product=new ProductA();
	           break;
                case2: product=new ProductB();
	           break;
                case3: product=new ProductC();
	           break;
	     }
	}
	void send()      //调用Do函数
	{
		product->Do();
	}
	~Factory(){      //析构
		delete product;
	}
};
 
int main()
{
	Factory *factory=new Factory(2);
	factory->send();
	return 0;
}

代码说明：示例代码给出的是Factory模式解决父类不知道具体实例化哪一个具体子类的问题，让其子类实现工厂接口，返回的也是一个抽象的产品。

将Factory的有参构造中的switch-case语句变为Product类指针。

#include<stdio.h>
#include<iostream>
 
using namespace std;
 
class Product{
public:
	virtual void Do()=0;
	virtual ~Product(){
		cout<<"Product is destructed!"<<endl;
	}
};
 
class ProductA:public Product{
public:
	void Do(){
		cout<<"正在制造ProductA!"<<endl;
	}
};
 
class ProductB:public Product{
public:
	void Do(){
		cout<<"正在制造ProductB!"<<endl;
	}
};
 
class ProductC:public Product{
public:
	void Do(){
		cout<<"正在制造ProductC!"<<endl;
	}
};
 
class Factory{
private:
	Product *product;
public:
	Factory(Product *t){
		product=t;
	}
	void send()
	{
		product->Do();
	}
	~Factory(){
		delete product;
	}
};
 
int main(void)
{
	Factory *factory=new Factory(new ProductB());
	factory->send();
	return 0;
}

增加多个Factory和Product类：

#include<stdio.h>
#include<iostream>
 
using namespace std;
 
class Product{
public:
	virtual void Do()=0;
	virtual ~Product(){
		cout<<"Product is destructed!"<<endl;
	}
};
 
class ProductA:public Product{
public:
	void Do(){
		cout<<"正在制造ProductA!"<<endl;
	}
};
 
class ProductB:public Product{
public:
	void Do(){
		cout<<"正在制造ProductB!"<<endl;
	}
};
 
class ProductC:public Product{
public:
	void Do(){
		cout<<"正在制造ProductC!"<<endl;
	}
};
 
class Factory{
protected:
	Product *product;
public:
	virtual void send()=0;
	virtual ~Factory(){}
};
 
class FactoryA: public Factory{
public:
	FactoryA(Product *t)
	{
		product=t;
	}
	void send()
	{
		product->Do();
	}
};
 
class FactoryB: public Factory{
public:
	FactoryB(Product *t)
	{
		product=t;
	}
	void send()
	{
		product->Do();
	}
};
 
class FactoryC: public Factory{
public:
	FactoryC(Product *t)
	{
		product=t;
	}
	void send()
	{
		product->Do();
	}
};
 
int main(void)
{
	Factory *factory=new Factory(new PruductA());
	factory->send();
	return 0;
}