自学设计模式（简单工厂模式、工厂模式、抽象工厂模式）

使用工厂模式来生产某类对象（代码简化且容易维护，类之间有血缘关系，可以通过工厂类进行生产）；

简单工厂模式（用于创建简单对象）

对于简单工厂模式，需要的工厂类只有一个；

在工厂类中的公共成员函数来创建所需对象；

#include <bits/stdc++.h>
using namespace std;
// 产品父类 
class shape{
public:
	virtual void cal() = 0;
	virtual ~shape(){
		
	}
}; 

class triangle:public shape{
public:
	void cal() override{
		cout<<"三角形面积";
	}
};

class square:public shape{
public:
	void cal() override{
		cout<<"正方形面积";
	}
};

class cycle:public shape{
public:
	void cal() override{
		cout<<"圆形面积";
	}
};

// 工厂类
enum class Type:char{
	triangle , 
	square , 
	cycle
};
class fac{
public:
	shape* creat_kinds(Type type){
		shape* ptr = nullptr;
		switch(type){
			case Type::triangle:
				ptr = new triangle;
				break;
			case Type::square:
				ptr = new square;
				break;
			case Type::cycle:
				ptr = new cycle;
				break;
		}
		return ptr;
	}
}; 
int main(){
	fac* cur = new fac;
	shape* obj = cur->creat_kinds(Type::cycle);
	obj->cal();
	return 0;
}

工厂模式

简单工厂模式会违反开放封闭原则 在添加类时需要修改子类、枚举类、工厂类、和判断代码

工厂模式通过创立N个工厂类来解决上述问题（对简单工厂模式解耦合），对已经写好的代码无需修改；

#include <bits/stdc++.h>
using namespace std;
// 产品父类 
class shape{
public:
	virtual void cal() = 0;
	virtual ~shape(){
		
	}
}; 

class triangle:public shape{
public:
	void cal() override{
		cout<<"三角形面积"<<endl;
	}
};

class square:public shape{
public:
	void cal() override{
		cout<<"正方形面积"<<endl;
	}
};

class cycle:public shape{
public:
	void cal() override{
		cout<<"圆形面积"<<endl;
	}
};

// 工厂类
class fac{
public:
	virtual shape* creat_kinds() = 0;
	virtual ~fac(){
		
	}
}; 

class triangle_fac:public fac{
public:
	shape* creat_kinds(){
		return new triangle;
	}
	~triangle_fac(){
		cout<<"三角形被析构"; 
	}
};
class square_fac:public fac{
public:
	shape* creat_kinds(){
		return new square;
	}
	~square_fac(){
		cout<<"三角形被析构"; 
	}
};

class cycle_fac:public fac{
public:
	shape* creat_kinds(){
		return new cycle;
	}
	~cycle_fac(){
		cout<<"三角形被析构"; 
	}
};
int main(){
	fac* cur = new cycle_fac;
	shape* obj = cur->creat_kinds();
	obj->cal();
	
	delete obj;
	delete cur;
	
	return 0;
}

抽象工厂模式

通过造船，船分为三个模块，船体、武器、动力，三个模块又分为了简易、标准、旗舰三个版本

#include <bits/stdc++.h>
using namespace std;
// 三个抽象类 每个抽象类下三个具体派生类
// 抽象工厂类 一个抽象类 三个派生类
class body{
public:
	virtual void getbody() = 0;
	virtual ~body(){
		
	}
}; 

class wood_body:public body{
public:
	void getbody() override{
		cout<<"船的船体为<木头>---";
	}
};

class iron_body:public body{
public:
	void getbody() override{
		cout<<"船的船体为<钢铁>---";
	}
};

class mental_body:public body{
public:
	void getbody() override{
		cout<<"船的船体为<合成金属>---";
	}
};

class weapon{
public:
	virtual void getweapon() = 0;
	virtual ~weapon(){
		
	} 
};

class gun_weapon:public weapon{
public:
	void getweapon() override{
		cout<<"船的武器为<枪>---" ;
	}
};

class cannon_weapon:public weapon{
public:
	void getweapon() override{
		cout<<"船的武器为<炮>---" ;
	}
};

class laser_weapon:public weapon{
public:
	void getweapon() override{
		cout<<"船的武器为<激光>---" ;
	}
};


class power{
public:
	virtual void getpower() = 0;
	virtual ~power(){
		
	} 
}; 

class human_power:public power{
public:
	void getpower() override{
		cout<<"船的动力为<手动>---"; 
	}
};

class engine_power:public power{
public:
	void getpower() override{
		cout<<"船的动力为<内燃机>---"; 
	}
};

class nuclear_power:public power{
public:
	void getpower() override{
		cout<<"船的动力为<核反应堆>---"; 
	}
};

class ship{
private:
	body* m_body;
	weapon* m_weapon;
	power* m_power;
public:
	ship(body* o_body , weapon* o_weapon , power* o_power):m_body(o_body) , m_weapon(o_weapon) , m_power(o_power){
		m_body->getbody();
		m_weapon->getweapon();
		m_power->getpower(); 
	}
	~ ship(){
		delete m_body;
		delete m_weapon;
		delete m_power;
	} 
};

class fac{
public:
	virtual ship* get() = 0;
	~ fac(){
		
	}
}; 

class e_fac:public fac{
public:
	ship* get() override{
		ship* cur = new ship(new wood_body , new gun_weapon , new human_power);
		return cur;
	}
};

class m_fac:public fac{
public:
	ship* get() override{
		ship* cur = new ship(new iron_body , new cannon_weapon , new engine_power);
		
		return cur;
	}
};

class h_fac:public fac{
public:
	ship* get() override{
		ship* cur = new ship(new mental_body , new laser_weapon , new nuclear_power);
		return cur;
	}
};

int main() {
	fac* cur = new h_fac;
	ship* res = cur->get();
	delete cur;
	delete res;
	return 0;
}

描述：首先定义三个抽象类，代表船的三个组成部分（船体、武器、动力）;每个抽象类下有三个派生类，分别对应初级船、中级船、高级船所用的对应材料。通过ship类将船的三个部分组成起来，一个工厂抽象类fac，通过工厂抽象类的派生类，结合ship类设置三种规格的船。