工厂模式（简单、标准、抽象）

最新推荐文章于 2024-10-31 18:26:46 发布
最新推荐文章于 2024-10-31 18:26:46 发布
阅读量143 收藏 1
点赞数
分类专栏： QT c/c++ 文章标签： c++ 开发语言 qt5 qt
原文链接：https://blog.csdn.net/m0_46210273/article/details/108450940
版权
QT 同时被 2 个专栏收录
143 篇文章 25 订阅
订阅专栏
c/c++
88 篇文章 2 订阅
订阅专栏
本文详细介绍了工厂模式的三种分类：简单工厂模式、标准工厂模式和抽象工厂模式。通过水果和果汁的例子展示了各自的特点。简单工厂模式中，一个工厂生产多种产品；标准工厂模式中，每个工厂专注于生产一种产品；抽象工厂模式则更加灵活，能生产一系列相关产品。文章强调了开放-封闭原则，并对比了各种模式的优缺点。
摘要由CSDN通过智能技术生成

该文章绝大部分内容都是转载一位老大哥的，我感觉他写的很好，原文链接在下。
版权声明：本文为CSDN博主「帅B猪」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_46210273/article/details/108450940

工厂模式，大概有三种分类：简单工厂模式，标准工厂模式和抽象工厂模式。
说实话平时开发好像哪一种都用的不是很规范，都是根据需要来调整，都会在标准的基础上增删。
工厂模式(统称)
工厂模式是一种创建型模式，适用场景：安全的创建对象。

简单工厂模式
顾名思义，工厂是用来生产东西的，而在C++里面就是用来生产对象的。
就像一家餐厅一样，你可以按照你的方式来点餐。在工厂模式中也一样，你可以要求工厂为你生产不同的对象。

#include<iostream>
#include<string>
using namespace std;
class Produce;//声明产品类 
class Factory;//声明工厂类 
class Factory
{
	public:
		Factory(){
		}
		~Factory(){
		}
		virtual Produce* create_produce(string class_name,string name)=0;
											//工厂生产产品,这里的纯虚函数是为了让子工厂生产产品
											//返回的是一个产品类指针，这就代表了一个产品
											//这里的name参数是为了返回想要的产品qwq 
};
class Produce
{
	public:
		Produce(){
		}
		~Produce(){
		}
		virtual void show_myname()=0;//这里定义的纯虚函数是为了让派生类去实现这个函数，有纯虚函数的类是抽象类 
};
//现在我要开始创建具体的产品了
class Produce_apple:public Produce//这是一个具体的苹果类 
{
	private:
		string name;
	public:
		Produce_apple(string new_name="")
		{
			this->name = new_name;
		}
		virtual void show_myname()//重写父类函数 
		{
			cout<<"我的名称是："<<name<<endl;
		}
};
class Produce_pear:public Produce//这是一个具体的梨类 
{
	private:
		string name;
	public:
		Produce_pear(string new_name="")
		{
			this->name = new_name;
		}
		virtual void show_myname()//重写父类函数
		{
			cout<<"我的名称是："<<name<<endl;
		}
};
class Produce_badfruits:public Produce//这是一个具体的坏水果类 
{
	private:
		string name;
	public:
		Produce_badfruits(){
		}
		virtual void show_myname()//重写父类函数
		{
			cout<<"此产品已经过期！！"<<endl;
		}
};
//下面开始创建具体的工厂类 
class Factory_fruits:public Factory//这是个水果工厂类
{
	public:
		Factory_fruits(){
		}
		~Factory_fruits(){
		}
		virtual Produce* create_produce(string class_name,string name)
		{
			if (class_name=="apple")
			{
				Produce * my_produce = new Produce_apple(name);//创建name的apple产品 
				return my_produce;
			}
			else if (class_name=="pear")
			{
				Produce * my_produce = new Produce_pear(name);//创建name的pear产品
				return my_produce;
			}
			else
			{
				Produce * my_produce = new Produce_badfruits();//创建name的pear产品
				return my_produce;
			}
		}
};
//初期的搭建工作已经完成，总结一下，我们搭建了两个抽象类：工厂类，产品类；
											    //产品派生类：苹果类，梨类，坏水果类
												//工厂派生类：水果工厂类。
												//现在我们要用这些东西了
int main()
{
	Factory * my_factory_fruits = new Factory_fruits();//创建一个抽象工厂对象"升级"为水果工厂
													//这里的"升级"是我的理解 ,事实上是类型转换 
	Produce * my_produce_apple = my_factory_fruits->create_produce("apple","红富士");
	//创建抽象产品对象，"升级"为水果工厂加工出来的apple,红富士 
	Produce * my_produce_pear = my_factory_fruits->create_produce("pear","冰糖雪梨");
	//创建抽象产品对象，"升级"为水果工厂加工出来的pear,冰糖雪梨
	Produce * my_produce_banana = my_factory_fruits->create_produce("banana","大香蕉");
	//创建抽象产品对象，"升级"为水果工厂加工出来的banana,大香蕉，但是工厂不能生产banana,所以只能生产badfruit坏水果 
	my_produce_apple->show_myname();
	//产品显示自己的名称 
	my_produce_pear->show_myname();
	//产品显示自己的名称
	my_produce_banana->show_myname();
	//产品显示自己的名称
		
	//下面是销毁内存
	delete my_factory_fruits;
	my_factory_fruits = NULL;
	delete my_produce_apple;
	my_produce_apple = NULL;
	delete my_produce_pear;
	my_produce_pear = NULL;
	delete my_produce_banana;
	my_produce_banana = NULL;
	return 0; 
}

标准工厂模式
顾名思义工厂模式，并没有那么简单qwq.他不是像简单工厂那样一个水果工厂可以生产各种水果，而是一种工厂生产一种水果。就比如苹果工厂生产苹果，梨子工厂生产梨子。这样分开的好处是什么呢？
我看了很多博客，他们都提到了 开放-封闭原则，我用我自己的话来说，就是如果你想增加新西瓜的产品的话。用简单工厂模式需要增加一个西瓜类，然后在水果工厂里面增加分支。用工厂模式的话需要增加一个西瓜类和一个西瓜类工厂。
但是我们的老师经常教导我们，不要改源码！！！如果用的是简单工厂模式就必须改源码中的条件分支，这会被老师骂死的qwq。所以用工厂模式就不用改源码，只用增加代码即可，妈妈再也不用担心我被骂了。

#include<iostream>
#include<string>
using namespace std;
class Produce;//声明产品类 
class Factory;//声明工厂类 
class Factory
{
  public:
  	Factory(){
  	}
  	~Factory(){
  	}
  	virtual Produce* create_produce(string name)=0;
  										//工厂生产产品,这里的纯虚函数是为了让子工厂生产产品
  										//返回的是一个产品类指针，这就代表了一个产品
  										//这里的name参数是为了返回想要的产品qwq 
};
class Produce
{
  public:
  	Produce(){
  	}
  	~Produce(){
  	}
  	virtual void show_myname()=0;//这里定义的纯虚函数是为了让派生类去实现这个函数，有纯虚函数的类是抽象类 
};
//现在我要开始创建具体的产品了
class Produce_apple:public Produce//这是一个具体的苹果类 
{
  private:
  	string name;
  public:
  	Produce_apple(string new_name="")
  	{
  		this->name = new_name;
  	}
  	virtual void show_myname()//重写父类函数 
  	{
  		cout<<"我的名称是："<<name<<endl;
  	}
};
class Produce_pear:public Produce//这是一个具体的梨类 
{
  private:
  	string name;
  public:
  	Produce_pear(string new_name="")
  	{
  		this->name = new_name;
  	}
  	virtual void show_myname()//重写父类函数
  	{
  		cout<<"我的名称是："<<name<<endl;
  	}
};
class Produce_banana:public Produce//这是一个具体的坏水果类 
{
  private:
  	string name;
  public:
  	Produce_banana(string new_name="")
  	{
  		this->name = new_name;
  	}
  	virtual void show_myname()//重写父类函数
  	{
  		cout<<"我的名称是："<<name<<endl;
  	}
};
//下面开始创建具体的工厂类 
class Factory_apple:public Factory//这是个水果工厂类
{
  public:
  	Factory_apple(){
  	}
  	~Factory_apple(){
  	}
  	virtual Produce* create_produce(string name)
  	{
  		Produce * my_produce = new Produce_apple(name);//创建name的apple产品 
  		return my_produce;
  	}
};
class Factory_pear:public Factory//这是个水果工厂类
{
  public:
  	Factory_pear(){
  	}
  	~Factory_pear(){
  	}
  	virtual Produce* create_produce(string name)
  	{
  		
  		Produce * my_produce = new Produce_pear(name);//创建name的pear产品 
  		return my_produce;
  	}
};
class Factory_banana:public Factory//这是个水果工厂类
{
  public:
  	Factory_banana(){
  	}
  	~Factory_banana(){
  	}
  	virtual Produce* create_produce(string name)
  	{
  		
  		Produce * my_produce = new Produce_banana(name);//创建name的badfruits产品 
  		return my_produce;
  	}
};
//初期的搭建工作已经完成，总结一下，我们搭建了两个抽象类：工厂类，产品类；
  										    //产品派生类：苹果类，梨类，坏水果类
  											//工厂派生类：苹果工厂类。梨类工厂类。坏水果工厂类 
  											//现在我们要用这些东西了
int main()
{
  Factory * my_factory_apple = new Factory_apple();//创建一个抽象工厂对象"升级"为苹果工厂
  												//这里的"升级"是我的理解 ,事实上是类型转换
  Factory * my_factory_pear = new Factory_pear();//创建一个抽象工厂对象"升级"为梨子工厂
  												
  Factory * my_factory_banana = new Factory_banana();//创建一个抽象工厂对象"升级"为香蕉工厂
  												
  Produce * my_produce_apple = my_factory_apple->create_produce("红富士");
  //创建抽象产品对象，"升级"为苹果工厂加工出来的apple,红富士 
  Produce * my_produce_pear = my_factory_pear->create_produce("冰糖雪梨");
  //创建抽象产品对象，"升级"为梨子工厂加工出来的pear,冰糖雪梨
  Produce * my_produce_banana = my_factory_banana->create_produce("大香蕉");
  //创建抽象产品对象，"升级"为香蕉工厂加工出来的banana 
  my_produce_apple->show_myname();
  //产品显示自己的名称 
  my_produce_pear->show_myname();
  //产品显示自己的名称
  my_produce_banana->show_myname();
  //产品显示自己的名称
  	
  //下面是销毁内存
  delete my_factory_apple;
  my_factory_apple = NULL;
  delete my_factory_pear;
  my_factory_pear = NULL;
  delete my_factory_banana;
  my_factory_banana = NULL;
  delete my_produce_apple;
  my_produce_apple = NULL;
  delete my_produce_pear;
  my_produce_pear = NULL;
  delete my_produce_banana;
  my_produce_banana = NULL;
  return 0; 
}

抽象工厂模式
顾名思义这个模式比普通的工厂模式抽象一点。
按照我个人的理解，简单工厂模式，工厂模式，抽象模式主要的差别就在与工厂的分类不同。
简单工厂模式：一个产品一个工厂，十个产品一个工厂。总结：工厂可以生产所有产品
工厂模式：一个产品一个工厂，十个产品十个工厂。总结：工厂只能生产一个产品
抽象工厂模式：N个产品M个工厂。总结：工厂可以灵活的生产商品。

还是按刚才的例子，我现在要卖苹果，苹果汁，梨子，梨子汁。
简单工厂模式就是1个工厂卖3个产品。
工厂模式就是创建3个工厂卖3个产品。
抽象工厂模式就不一样：我可以创建两个工厂。一个专门卖苹果类的，一个专门卖梨子类的，除了这样的分类，还可以进行其他的分类，十分的灵活！

#include<iostream>
#include<string>
using namespace std;
class Produce_fruits;//声明水果产品类
class Produce_fruits_juice;//声明水果汁产品类  
class Factory;//声明工厂类 
class Factory
{
	public:
		Factory(){
		}
		~Factory(){
		}
		virtual Produce_fruits* create_produce(string name)=0;
											//工厂生产产品,这里的纯虚函数是为了让子工厂生产产品
											//返回的是一个产品类指针，这就代表了一个产品
											//这里的name参数是为了返回想要的产品qwq
		virtual Produce_fruits_juice* create_produce_juice(string name)=0;
											//工厂生产产品,这里的纯虚函数是为了让子工厂生产产品
											//返回的是一个产品类指针，这就代表了一个产品
											//这里的name参数是为了返回想要的产品qwq 
};
class Produce_fruits
{
	public:
		Produce_fruits(){
		}
		~Produce_fruits(){
		}
		virtual void show_myname()=0;//这里定义的纯虚函数是为了让派生类去实现这个函数，有纯虚函数的类是抽象类 
};
class Produce_fruits_juice
{
	public:
		Produce_fruits_juice(){
		}
		~Produce_fruits_juice(){
		}
		virtual void show_myname()=0;//这里定义的纯虚函数是为了让派生类去实现这个函数，有纯虚函数的类是抽象类 
};
//现在我要开始创建具体的产品了
class Produce_apple:public Produce_fruits//这是一个具体的苹果类 
{
	private:
		string name;
	public:
		Produce_apple(string new_name="")
		{
			this->name = new_name;
		}
		virtual void show_myname()//重写父类函数 
		{
			cout<<"我的名称是："<<name<<"（水果）"<<endl;
		}
};
class Produce_pear:public Produce_fruits//这是一个具体的梨类 
{
	private:
		string name;
	public:
		Produce_pear(string new_name="")
		{
			this->name = new_name;
		}
		virtual void show_myname()//重写父类函数
		{
			cout<<"我的名称是："<<name<<"（水果）"<<endl;
		}
};
class Produce_apple_juice:public Produce_fruits_juice//这是一个具体的苹果类 
{
	private:
		string name;
	public:
		Produce_apple_juice(string new_name="")
		{
			this->name = new_name;
		}
		virtual void show_myname()//重写父类函数 
		{
			cout<<"我的名称是："<<name<<"（果汁）"<<endl;
		}
};
class Produce_pear_juice:public Produce_fruits_juice//这是一个具体的梨类 
{
	private:
		string name;
	public:
		Produce_pear_juice(string new_name="")
		{
			this->name = new_name;
		}
		virtual void show_myname()//重写父类函数
		{
			cout<<"我的名称是："<<name<<"（果汁）"<<endl;
		}
};
//下面开始创建具体的工厂类 
class Factory_apple:public Factory//这是个苹果工厂类
{
	public:
		Factory_apple(){
		}
		~Factory_apple(){
		}
		virtual Produce_fruits* create_produce(string name)
		{
			Produce_fruits * my_produce = new Produce_apple(name);//创建name的苹果产品 
			return my_produce;
		}
		virtual Produce_fruits_juice* create_produce_juice(string name)
		{
			Produce_fruits_juice * my_produce = new Produce_apple_juice(name);//创建name的苹果汁产品 
			return my_produce;
		}
};
class Factory_pear:public Factory//这是个梨工厂类
{
	public:
		Factory_pear(){
		}
		~Factory_pear(){
		}
		virtual Produce_fruits* create_produce(string name)
		{
			Produce_fruits * my_produce = new Produce_pear(name);//创建name的梨子产品 
			return my_produce;
		}
		virtual Produce_fruits_juice* create_produce_juice(string name)
		{
			Produce_fruits_juice * my_produce = new Produce_pear_juice(name);//创建name的梨子汁产品 
			return my_produce;
		}
};
//初期的搭建工作已经完成，总结一下，我们搭建了两个抽象类：工厂类，水果产品类，果汁产品类；
											    //产品派生类：苹果类，梨类，苹果汁类，梨汁类，
												//工厂派生类：苹果工厂类，梨子工厂类。
												//现在我们要用这些东西了
int main()
{
	Factory * my_factory_apple = new Factory_apple();//创建一个抽象工厂对象"升级"为苹果工厂
													//这里的"升级"是我的理解 ,事实上是类型转换
	Factory * my_factory_pear = new Factory_pear();//创建一个抽象工厂对象"升级"为梨子工厂
													//这里的"升级"是我的理解 ,事实上是类型转换 
	Produce_fruits * my_produce_apple = my_factory_apple->create_produce("红富士");
	//创建抽象产品对象，"升级"为苹果工厂加工出来的红富士 
	Produce_fruits * my_produce_pear = my_factory_pear->create_produce("鸭梨");
	//创建抽象产品对象，"升级"为梨子工厂加工出来的鸭梨
	Produce_fruits_juice * my_produce_apple_juice = my_factory_apple->create_produce_juice("红苹果汁");
	//创建抽象产品对象，"升级"为苹果工厂加工出来的红苹果汁
	Produce_fruits_juice * my_produce_pear_juice = my_factory_pear->create_produce_juice("冰糖雪梨果汁");
	//创建抽象产品对象，"升级"为梨子工厂加工出来的冰糖雪梨果汁 
	my_produce_apple->show_myname();
	//产品显示自己的名称 
	my_produce_pear->show_myname();
	//产品显示自己的名称
	my_produce_apple_juice->show_myname();
	//产品显示自己的名称
	my_produce_pear_juice->show_myname();
	//产品显示自己的名称
	
	//下面是销毁内存 
	delete my_factory_apple;
	my_factory_apple = NULL;
	delete my_factory_pear;
	my_factory_pear = NULL;
	delete my_produce_apple;
	my_produce_apple = NULL;
	delete my_produce_pear;
	my_produce_pear = NULL;
	delete my_produce_apple_juice;
	my_produce_apple_juice = NULL;
	delete my_produce_pear_juice;
	my_produce_pear_juice = NULL;
	return 0; 
}
缺点（相对）：

简单工厂模式：违背了开放封闭原则（改动源码），产品多了会比较杂
工厂模式：产品多了会很杂，代码量稍大，产品多了会比较杂
抽象工厂模式：代码量大，产品多了会比较非常杂

优点（相对）：

简单工厂模式：代码量小，方便添加新的产品
工厂模式：不违背了开放封闭原则（不改动源码），方便添加新的产品
抽象工厂模式：不违背了开放封闭原则，模式灵活，调用方便

东方忘忧
关注
专栏目录
设计模式-简单工厂模式、工厂模式、抽象工厂模式在Java中的使用示例
BADAO_LIUMANG_QIZHI的博客
10-26 765
是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们的具体类。客户端(应用层)不依赖于产品类实例如何被创建、如何被实现等细节，强调的是一系列相关的产品对象(属于同一个产品族)一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。
标准工厂模式三层结构
05-02
对于刚毕业不久的同学们可能对工厂模式和三层结构还模糊不清，因为书本上只是侃侃而谈而实际例子有少之又少或者说简单之极。 我工作快2年了，可能自己太追求技术或者不注重构架，所以到最近才基本搞明白什么是工厂模式什么是三层结构，以及他们的优点，想想以前做的东西真是垃圾不堪。呵呵，废话不多说了，这个51没啥事做，就把我对三层结构和工厂模式的理解做了一个例子，很详尽的用代码方式展示给大家，不管是在代码编写上还是架构上都十分详细，要是你觉得小弟有什么做的不好的或者不完善的地方欢迎你给我交流 QQ：10907034 (PS:要是你是正在找工作的学生，面试单位要求你提供实例代码，你不仿可以将这个拿去一试，你的工作几乎可能会大很多哦～^_^)
简单工厂模式、工厂模式、抽象工厂模式
祥子的博客
09-07 423
一、简单工厂模式 突然有一天，在梦里拥有了阿拉丁神灯. 灯神说: "我可以给你创造一个女朋友哦" 这时候我的心里...嘿嘿嘿... "但是只能满足你一个地理条件，目前只有三个选项: 四川, 河北, 山东. 你挑一个? " 灯神又说. "那我选: 四川...或者..." 没等我说完，嘭的一下，出来个一个火辣的川妹子...
工厂模式-简单工厂模式-标准工厂模式
村长Korbin
05-08 1130
2 工厂模式         2.1 工厂模式的几种形态         工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类，工厂模式有以下几种形态：         (1) 简单工厂模式：又称静态工厂方法模式。         (2) 工厂方法模式：又称多态性工厂模式或虚拟构造子模式。         (3) 抽象工厂
简单工厂模式、工厂模式与抽象工厂模式详解
2302_77758423的博客
05-18 1381
设计模式是一套被反复使用、多数人认可的、经过分类编目的、代码设计经验的总结。它们为软件设计提供了一定的指导和最佳实践。特别是在创建对象时，简单工厂、工厂模式和抽象工厂模式这三种创建型模式经常被提及和应用。简单工厂模式是一种创建型设计模式，它通过一个单一的工厂类来负责创建一系列相关的对象。这个工厂类根据传入的参数来决定实例化哪一个具体类的实例。客户端在使用时不需要知道具体的类名，只需要提供必要的信息给工厂。工厂模式属于创建型模式，它在创建对象时提供了一种封装机制，将实际创建对象的代码与使用代码分离。
设计模式 - 工厂模式、建造者模式，就该这样学！
CYK_byte的博客
10-08 2830
简单工厂不是一种设计模式，反而比较像是一种编程习惯.抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。具体产品 ：实现或者继承抽象产品的子类具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。
简单工厂模式+工厂方法模式+抽象工厂模式
weixin_45776349的博客
08-17 335
创建型模式 这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。 1. 工厂模式定义 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可
设计模式-抽象工厂模式(Abstract Factory)
zhao_kang_cheng的专栏
09-11 882
是一种创建型设计模式， 它能创建一系列相关的对象， 而无需指定其具体类。譬如 你正在开发一款家具组装系统。代码中包括一些产品：椅子（chair）,沙发（sofa）和 咖啡桌（Coffee­Table） 然后基于这些产品形成一些列组合套餐 装饰风艺术(Art Deco)、维多利亚（Victorian）和现代（Mdern）。你需要设法单独生成每件家具对象， 这样才能确保其风格一致。如果顾客收到的家具风格不一样， 他们可不会开心。此外， 你也不希望在添加新产品或新风格时修改已有代码。
23模式---简单工厂模式，工厂模式，抽象工厂模式
u011863822的博客
10-26 416
本篇注意通过实例来聊了一下工厂模式中的，简单工厂模式，工厂模式，以及抽象工厂模式三种的优缺点，以及适用的场景。
java三大工厂模式（简单工厂模式，工厂方法模式，抽象工厂模式）
QyangR1123的博客
10-13 828
工厂模式主要是通过把创建对象的代码包装起来，做到创建对象的代码与具体的业务逻辑代码相隔离的目的。工厂模式可以细分为：简单工厂模式，工厂方法模式，抽象工厂模式。通过我们上面的各种例子，我们可以发现不管我们怎么修改设计方式，都不能够同时满足灵活性高和不违反开闭原则。如果要同时满足的话，就需要引入反射的思想，通过反射+抽象工厂的方式实现。
工厂模式、简单工厂模式、抽象工厂模式、反射工厂模式
09-06
总的来说，工厂模式是软件设计中不可或缺的一部分，它为对象的创建提供了标准化的方式，使得代码更加模块化和易于管理。通过对这四种工厂模式的深入理解和应用，开发者可以更好地应对复杂的对象创建问题，提高代码的...
嵌入式C语言设计模式 --- 抽象工厂模式
EmbedIoT Studio
12-29 535
抽象工厂模式，是一种为访问类提供一个创建一组相关或相互依赖对象的接口，而且访问类无需指定所要产品的具体类就能够得到同族产品不同等级的产品的模式结构。
理解设计模式：简单工厂模式、工厂方法和抽象工厂模式
"深入浅出设计模式探讨了工厂模式在软件开发中的应用，包括静态工厂模式、工厂方法模式和抽象工厂模式，旨在提高代码的灵活性和封装性。" 设计模式是软件开发中的一种最佳实践，它提供了解决特定问题的标准解决方案...
简单工厂模式&工厂方法模式&抽象工厂模式的区别及优缺点及使用场景
auuea的博客
12-01 4万+
简单工厂模式&amp;amp;amp;工厂方法模式&amp;amp;amp;抽象工厂模式的区别及优缺点及使用场景简单工厂普通简单工厂多方法简单工厂静态方法简单工厂工厂方法模式抽象工厂模式 工厂模式是java设计模式中比较简单的一个设计模式，但很多地方都用到了工厂模式，（如解析xml中，jdbc连接数据库等）利用好工厂模式对程序的设计很有用处。 工厂模式在一些设计模式的书中分为简单工厂模式，工厂方法模式和抽象工厂模式三类。也有把工...
简单工厂模式、工厂模式以及抽象工厂模式（具体）
热门推荐
cosmos_lee
06-29 8万+
抽象工厂模式：我们现在要对mysql/oracle数据库中的User表进行操作，User表定义如下：public class User { private int uid; private String uname; public int getUid() { return uid; } public void setUid(int ui...
《C++显式类型转换：解析多种转换方式的奥秘》
xy520521的博客
10-27 697
当我们从一个存储 Shape 指针的容器中取出指针并希望将其转换为具体的派生类指针以调用特定的绘制方法时，动态_cast可以确保转换的安全性，避免在对象类型不匹配时出现错误。需要注意的是，使用 const_cast修改一个原本被定义为 const 的对象可能会导致未定义的行为，因为这违反了 const 的语义。例如，当我们有一个 const 引用指向一个对象，但在某个特定的函数内部，我们知道这个函数不会修改对象的值，但需要将其传递给一个非 const 版本的函数时，可以使用 const_cast。
「C/C++」C/C++标准库之#include＜cstdlib＞通用工具库
何曾参静谧的博客
10-28 572
是C++标准库中的一个头文件，它提供了各种通用工具函数，这些函数最初来源于C标准库中的，并在C++中进行了标准化和扩展。在C++编程中，头文件具有重要地位，它涵盖了字符串转换、类型转换、随机数生成、内存管理和系统调用等多个方面的功能。通过这些实例，我们可以看到头文件在C++编程中的广泛应用。它提供了一系列功能强大的函数，使得开发者能够方便地处理字符串转换、随机数生成、内存管理等任务。在实际开发中，合理利用这些函数可以大大提高编程效率和代码质量。
C/C++：WinSock_TCP通信实例
qq_55038440的博客
10-28 976
1.AF地址族 1.SOCKADDR本地地址结构体 2.SOCKADDR_IN TCP/IP地址结构体 案例：指定端口号代码 案例：指定 IP地址代码 三、监听套接字 四、接收连接请求 1.accept()函数 函数原型如下： 2.connect()函数 函数原型如下： 五、收发数据 1.send()函数 函数原型如下 2.recv()函数 函数原型如下
第九天: 深入探索C语言中的动态内存管理
最新发布
qq_57484399的博客
10-31 161
简单来说，就是C语言没有直接提供给我们的数据类型，但是C语言给我们留了一个后门，允许我们用一些特殊的关键字来定义自己的数据类型。枚举类型允许我们定义一组相关的常量，这些常量就是枚举类型的取值。听起来有点绕？我给你举个例子。比如说，我们要表示一周的七天，我们可以用字符串来表示，但处理起来比较麻烦。用整数表示就简单多了，星期一是1，星期二是2，以此类推。这样的变量就可以定义为枚举类型，它的取值范围就是1到7。首先，我们用struct关键字来定义一个结构体。
JAVA工厂模式详解：简单工厂到抽象工厂
这种模式可以分为三种形态：简单工厂模式、工厂方法模式和抽象工厂模式。" 在【标题】"JAVA工厂模式-JAVA之工厂模式"中，我们讨论的是Java编程中的工厂模式，这是一种设计模式，用于在运行时创建对象，而无需暴露...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值