3.C++设计模式-创建型模型

3.C++设计模式-创建型模型

3.1 简单工厂模式

3.1.1 理论

3.1.2 简单工厂模式案例

不难看出，Fruit类是一个“巨大的”类，在该类的设计中存在如下几个问题：

(1) 在Fruit类中包含很多“if…else…”代码块，整个类的代码相当冗长，代码越长，阅读难度、维护难度和测试难度也越大；而且大量条件语句的存在还将影响系统的性能，程序在执行过程中需要做大量的条件判断。

(2) Fruit类的职责过重，它负责初始化和显示所有的水果对象，将各种水果对象的初始化代码和显示代码集中在一个类中实现，违反了“单一职责原则”，不利于类的重用和维护；

(3) 当需要增加新类型的水果时，必须修改Fruit类的源代码，违反了“开闭原则”。

#include 
using namespace std;

//抽象水果
class AbstractFruit {
public:
	virtual void ShowName() = 0;
};

//苹果
class Apple :public AbstractFruit {
public:
	virtual void ShowName() {
		cout << "我是苹果!" << endl;
	}
};

//香蕉
class Banana :public AbstractFruit {
public:
	virtual void ShowName() {
		cout << "我是香蕉!" << endl;
	}
};

//鸭梨
class Pear :public AbstractFruit {
public:
	virtual void ShowName() {
		cout << "我是鸭梨!" << endl;
	}
};

//水果工厂
class FruitFactor {
public:
	static AbstractFruit * CreateFruit(string flag) {
		if (flag == "apple") {
			return new Apple;
		}
		else if (flag == "banana") {
			return new Banana;
		}
		else if (flag == "pear") {
			return new Pear;
		}
		else {
			return NULL;
		}
	}
};

void test01() {
	FruitFactor* factory = new FruitFactor;
	AbstractFruit* fruit = factory->CreateFruit("apple");
	fruit->ShowName();
	delete fruit;

	fruit = factory->CreateFruit("banana");
	fruit->ShowName();
	delete fruit;

	fruit = factory->CreateFruit("pear");
	fruit->ShowName();
	delete fruit;

	fruit = NULL;
	delete factory;
	factory = NULL;
}

int main(){
	test01();
	return 0;
}

3.1.3 简单工厂模式的优缺点

优点：

(1)实现了对象创建和使用的分离。

(2)不需要记住具体类名，记住参数即可，减少使用者记忆量。

缺点：

(1)对工厂类职责过重，一旦不能工作，系统受到影响。

(2)增加系统中类的个数，复杂度和理解度增加。

(3)违反“开闭原则”，添加新产品需要修改工厂逻辑，工厂越来越复杂。

3.1.4 适用场景

（1）工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。

（2）客户端只知道传入工厂类的参数，对于如何创建对象并不关心。

3.2 工厂方法模式

3.2.1 工厂方法模式理论

简单工厂模式 + “开闭原则” = 工厂方法模式

工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭 原则’，实现了可扩展。

3.2.2 工厂方法模式案例

#include 
using namespace std;

//抽象水果
class AbstractFruit {
public:
	virtual void ShowName() = 0;
};

//苹果
class Apple :public AbstractFruit {
public:
	virtual void ShowName() {
		cout << "我是苹果!" << endl;
	}
};

//香蕉
class Banana :public AbstractFruit {
public:
	virtual void ShowName() {
		cout << "我是香蕉!" << endl;
	}
};

//鸭梨
class Pear :public AbstractFruit {
public:
	virtual void ShowName() {
		cout << "我是鸭梨!" << endl;
	}
};

//抽象工厂
class AbstractFruitFactory {
public:
	virtual AbstractFruit* CreateFruit() = 0;
};


//苹果工厂
class AppleFactory :public AbstractFruitFactory {
public:
	virtual AbstractFruit* CreateFruit() {
		return new Apple;
	}
};

//香蕉工厂
class BananaFactory :public AbstractFruitFactory {
public:
	virtual AbstractFruit* CreateFruit() {
		return new Banana;
	}
};

//鸭梨工厂
class PearFactory :public AbstractFruitFactory {
public:
	virtual AbstractFruit* CreateFruit() {
		return new Pear;
	}
};


void test01() {
	AbstractFruitFactory* factory = NULL;
	AbstractFruit* fruit = NULL;

	//创建一个苹果工厂
	factory = new AppleFactory;
	fruit = factory->CreateFruit();
	fruit->ShowName();
	delete fruit;
	delete factory;

	//创建一个香蕉工厂
	factory = new BananaFactory;
	fruit = factory->CreateFruit();
	fruit->ShowName();
	delete fruit;
	delete factory;

	//创建一个鸭梨工厂
	factory = new PearFactory;
	fruit = factory->CreateFruit();
	fruit->ShowName();
	delete fruit;
	delete factory;
	fruit = NULL;
	factory = NULL;

}

int main() {
	test01();
	return 0;
}

3.2.3 工厂方法模式的总结

传统：如果想创建两个苹果，得具体实例化两个，然后再调用功能，以后再用还得记名字

Apple a；
a.func();
Aplle b；
b.func();

工厂方法模式：可以不用具体一个对象，然后调用

factory = new AppleFactory;
fruit = factory->CreateFruit();//造a
fruit->ShowName();
fruit = factory->CreateFruit();//造b
fruit->ShowName();

3.3 抽象工厂模式

3.3.1 抽象工厂模式理论

中国的那一行就是产品族

3.3.2 抽象工厂模式案例

#include 
using namespace std;

//抽象苹果
class AbstractApple {
public:
	virtual void ShowName() = 0;
};

//中国苹果
class ChinaApple :public AbstractApple {
public:
	virtual void ShowName() {
		cout << "中国苹果！" << endl;
	}
};

//美国苹果
class USAApple :public AbstractApple {
public:
	virtual void ShowName() {
		cout << "美国苹果！" << endl;
	}
};

//日本苹果
class JapanApple :public AbstractApple {
public:
	virtual void ShowName() {
		cout << "日本苹果！" << endl;
	}
};

//抽象香蕉
class AbstractBanana {
public:
	virtual void ShowName() = 0;
};

//中国香蕉
class ChinaBanana :public AbstractBanana {
public:
	virtual void ShowName() {
		cout << "中国香蕉！" << endl;
	}
};

//美国香蕉
class USABanan :public AbstractBanana {
public:
	virtual void ShowName() {
		cout << "美国香蕉！" << endl;
	}
};

//日本香蕉
class JapanBanan :public AbstractBanana {
public:
	virtual void ShowName() {
		cout << "日本香蕉！" << endl;
	}
};

//抽象鸭梨
class AbstractPear {
public:
	virtual void ShowName() = 0;
};


//中国鸭梨
class ChinaPear:public AbstractPear{
public:
	virtual void ShowName() {
		cout << "中国鸭梨！" << endl;
	}
};

//美国鸭梨
class USAPear :public AbstractPear {
public:
	virtual void ShowName() {
		cout << "美国鸭梨！" << endl;
	}
};

//日本鸭梨
class JapanPear :public AbstractPear {
public:
	virtual void ShowName() {
		cout << "日本鸭梨！" << endl;
	}
};


//抽象工厂 针对产品族
class AbstractFactory {
public:
	virtual AbstractApple* CreateApple() = 0;
	virtual AbstractBanana* CreateBanana() = 0;
	virtual AbstractPear* CreatePear() = 0;
};

//中国工厂
class ChinaFactory :public AbstractFactory {
public:
	virtual AbstractApple* CreateApple() {
		return new ChinaApple;
	}
	virtual AbstractBanana* CreateBanana(){
		return new ChinaBanana;
	}
	virtual AbstractPear* CreatePear() {
		return new ChinaPear;
	}
};

//美国工厂
class USAFactory :public AbstractFactory {
public:
	virtual AbstractApple* CreateApple() {
		return new USAApple;
	}
	virtual AbstractBanana* CreateBanana() {
		return new USABanan;
	}
	virtual AbstractPear* CreatePear() {
		return new  USAPear;
	}
};

//日本工厂
class JapanFactory :public AbstractFactory {
public:
	virtual AbstractApple* CreateApple() {
		return new JapanApple;
	}
	virtual AbstractBanana* CreateBanana() {
		return new JapanBanan;
	}
	virtual AbstractPear* CreatePear() {
		return new  JapanPear;
	}
};

void test01() {
	AbstractFactory* factory = NULL;
	AbstractApple* apple = NULL;
	AbstractBanana* banana = NULL;
	AbstractPear* pear = NULL;

	//中国工厂
	factory = new ChinaFactory;
	apple = factory->CreateApple();
	banana = factory->CreateBanana();
	pear = factory->CreatePear();

	apple->ShowName();
	banana->ShowName();
	pear->ShowName();
}

int main() {
	test01();
	return 0;
}

3.3.3 抽象工厂的优缺点

• 优点：

(1)拥有工厂方法模式的优点

(2)当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。

(3)增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。

• 缺点：

​ 增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。

3.3.4 适用场景

(1) **系统中有多于一个的产品族。**而每次只使用其中某一产品族。可以通过配置文件等方式来使得用户可以动态改变产品族，也可以很方便地增加新的产品族。

(2) 产品等级结构稳定。设计完成之后，不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。

3.4 单例模式

其余四种：https://blog.csdn.net/zhiyuan2021/article/details/108032795

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

3.4.1 单例模式理论

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

实现单例步骤：

1.构造函数私有化
2.增加静态私有的当前类的指针变量
3.提供静态对外接口，可以让用户获得单例对象

3.4.2 单例模式案例

1.懒汉式(需要的时候才会创建)

2.饿汉式(直接创建，理解为main执行前，就创建好了)

#include 
using namespace std;


class A {
private:
	A() {
		a = new A;
	}
public:
	static A* getInstance() {
		return a;
	}
private:
	static A* a;
};


A* A::a = NULL;

//实现单例步骤
//1.构造函数私有化
//2.增加静态私有的当前类的指针变量
//3.提供静态对外接口，可以让用户获得单例对象

//单例 分为懒汉式 饿汉式

//1.懒汉式(需要的时候才会创建)
class Singleton_lazy {
private:
	Singleton_lazy() { cout << "我是懒汉构造！" << endl; }
public:
	static Singleton_lazy* getInstance() {
		if (pSingleton == NULL) {
			pSingleton = new Singleton_lazy;
		}
		return pSingleton;
	}
private:
	static Singleton_lazy* pSingleton;
};

//类外初始化
Singleton_lazy* Singleton_lazy::pSingleton = NULL;

//2.饿汉式
class Singleton_hungry {
private:
	Singleton_hungry() { cout << "我是饿汉构造！" << endl; }
public:
	static Singleton_hungry* getInstance() {
		return pSingleton;
	}
private:
	static Singleton_hungry* pSingleton;
};

//类外初始化
Singleton_hungry* Singleton_hungry::pSingleton = new Singleton_hungry;

void test01() {
	Singleton_lazy* p1 = Singleton_lazy::getInstance();
	Singleton_lazy* p2 = Singleton_lazy::getInstance();
	if (p1 == p2) {
		cout << "两个指针指向同一块内存空间，是单例！" << endl;
	}
	else {
		cout << "不是单例模式！" << endl;
	}

	Singleton_hungry* p3 = Singleton_hungry::getInstance();
	Singleton_hungry* p4 = Singleton_hungry::getInstance();
	if (p3 == p4) {
		cout << "两个指针指向同一块内存空间，是单例！" << endl;
	}
	else {
		cout << "不是单例模式!" << endl;
	}
}


int main() {

	//A a; // 或A*a=new A;  这两个会调用构造函数，要让不能构造函数
	//A::getInstance();

	test01();
	cout << "main函数开始执行！" << endl;



	return 0;
}

3.4.3 单例对象释放

不考虑内存释放问题

1.单例对象从头到尾就一份内存，没必要释放

2.如果非要提供释放，可以如下，运行完自动释放：

#include 
using namespace std;

//实现单例步骤
//1.构造函数私有化
//2.增加静态私有的当前类的指针变量
//3.提供静态对外接口，可以让用户获得单例对象

//单例 分为懒汉式 饿汉式

//1.懒汉式(需要的时候才会创建)
class Singleton_lazy {
private:
	Singleton_lazy() { cout << "我是懒汉构造！" << endl; }
public:
	static Singleton_lazy* getInstance() {
		if (pSingleton == NULL) {
			pSingleton = new Singleton_lazy;
		}
		return pSingleton;
	}
#if 0 
	//这样释放不行，万一谁手贱释放，就直接没了，这个权限不能给
	static void freeSpace() {
		if (pSingleton != NULL) {
			delete pSingleton;
		}
	}
#endif
	//如果非要写，可以加个这个，运行完自动释放
	class Garbo {
		Garbo() {
			if (pSingleton != NULL) {
				delete pSingleton;
			}
		}
	};


private:
	static Singleton_lazy* pSingleton;
	static Garbo garbo;
};

//类外初始化
Singleton_lazy* Singleton_lazy::pSingleton = NULL;

//2.饿汉式
class Singleton_hungry {
private:
	Singleton_hungry() { cout << "我是饿汉构造！" << endl; }
public:
	static Singleton_hungry* getInstance() {
		return pSingleton;
	}
private:
	static Singleton_hungry* pSingleton;
};

//类外初始化
Singleton_hungry* Singleton_hungry::pSingleton = new Singleton_hungry;

void test01() {
	Singleton_lazy* p1 = Singleton_lazy::getInstance();
	Singleton_lazy* p2 = Singleton_lazy::getInstance();
	if (p1 == p2) {
		cout << "两个指针指向同一块内存空间，是单例！" << endl;
	}
	else {
		cout << "不是单例模式！" << endl;
	}

	Singleton_hungry* p3 = Singleton_hungry::getInstance();
	Singleton_hungry* p4 = Singleton_hungry::getInstance();
	if (p3 == p4) {
		cout << "两个指针指向同一块内存空间，是单例！" << endl;
	}
	else {
		cout << "不是单例模式!" << endl;
	}
}

#if 0
void test02() {
	Singleton_lazy::freeSpace();
}
#endif


int main() {

	test01();
	cout << "main函数开始执行！" << endl;
	return 0;
}

3.4.4 单例模式遇到多线程

要加锁

1）懒汉式碰到多线程是线程不安全的，比如下班两个都判别pSingleton ==NULL，都创建一个，就不是单例了

2）饿汉式是线程安全的
main执行前，就创建好了？（存疑）

3.4.5 单例模式的优缺点

优点：

(1)单例模式提供了对唯一实例的受控访问

(2)节约系统资源。由于在系统内存中只存在一个对象。

缺点：

(1) 扩展略难。单例模式中没有抽象层。

(2) 单例类的职责过重。

3.4.6 适用场景

(1)
系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器或资源管理器（像windows的资源管理器），或者需要考虑资源消耗太大而只允许创建一个对象。

(2) 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。