创建型模型
简单工厂模式
我们不想直接手动从头创建一个对象，而是调用一个工厂（函数）去帮我们创建出一个个对象，我们只需要输入对象的参数就可以
我们先创建一个水果的抽象类，然后子类创建出很多其他水果类。最后利用一个类区调用水果的子类去创建出我们需要的水果 （这个工厂类类利用if else 根据我们传入的参数来创建对应的类）
#include <bits/stdc++.h>
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
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;
}
简单工厂模式的优缺点
优先：
1、实现了对象的创建和使用的分离
2、不需要记住具体的类名记住参数就可以，减少使用者的记忆
缺点：
1、对工厂的职责过重，一旦不能工作，系统受到影响
2、增加系统中类的个数，复杂度和理解度增加
3、违反开闭原则，添加新产品需要修改工厂的逻辑（源代码），工厂原来越复杂
适用场景
1、工厂类负责创建的对象比较少，由于创建的对象少，不会造成工厂方法的业务逻辑太过复杂
2、客户端只知道传入工厂类的参数，对于如何创建对象并不关心
工厂方法模式
简单工厂模型 + 开闭原则 = 工厂方法模型
我们在功能扩展的时候只会添加新的代码不会修改原来的代码，我们直接利用父类指针调用子类对象，
案例解析
抽象水果衍生出各种水果，抽象工厂衍生出各种水果工厂
#include <bits/stdc++.h>
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;
}
工厂方法模式的总结
传统：如果想创建两个苹果，得实例化两个，然后再调用功能，以后再用还得记住名字
Apple a；
a.func();
Aplle b；
b.func();
工厂方法模式：可以不用具体一个对象，然后调用
factory = new AppleFactory;
fruit = factory->CreateFruit();//造a
fruit->ShowName();
fruit = factory->CreateFruit();//造b
fruit->ShowName();
抽象工厂模式
抽象苹果生成多个国家的苹果，抽象工厂生成多个国家的工厂。抽象工厂生成多种水果
与之前的工厂模型相比不同就是将抽象工厂做成了多个类的集合，从原来的当一加工工厂变成了多产品加工工厂
#include <bits/stdc++.h>
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;
}
单例模式
单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案
实现单例步骤：
1.构造函数私有化
2.增加静态私有的当前类的指针变量
3.提供静态对外接口，可以让用户获得单例对象
单例模式案例
1.懒汉式(需要的时候才会创建实例对象)
2.饿汉式(直接创建，理解为main执行前，就创建好了实例对象)
#include <iostream>
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;
}
单例对象释放
不考虑内存释放问题
1、单例对象从头到尾就一份内存，没必要释放
2、如果非要提供释放，可以如下，运行完自动释放
#include <iostream>
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;
}
单例模式遇到多线程
两个线程函数对一个内存空间竞争资源，要加锁防止其他线程搞破坏
懒汉模式碰到多线程是线程不安全的，比如下班两个都判别为pSingleton = NULL ，都创建一个，就不是单例了
饿汉式是线程安全的
main执行前，就创建好了，线程函数还没来得及调用实现多线程
单例模式的优缺点
优先：
1、单例模式提供了唯一实例控制的受控访问
2、节约系统资源，由于在系统内存中只存在一个对象
缺点：
1、扩展略难，单例模式中没有抽象层
2、单例类的职责过重
适用场景
1、系统只需要一个实例对象，如系统要求提供唯一一个序列号生成器或资源管理器（像window的资源管理器），或者需要考虑资源消耗太大而只允许创建一个对象
3、客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例
892
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
