【原】常见设计模式--C++基础

KookNut39 2021-12-15

展开全文

单件模式(SINGLETON)：
意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
动机：对于一些类来说，只有一个实例是很重要的。比如董事长是一个类，不同的公司可以有不同的董事长，但是一个公司只能有一个董事长，来对公司的各项决议做最终决定。
思考：我们怎么做才能使得这一个类只有一个实例并且实例易于被访问？全局变量是我们思考的一种方法，但是全局变量并不能使实例唯一化。
解决办法：让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且可以提供一个可以访问该实例的方法。
废话不多说，看实例代码：

class Singleton
{
public:
static Singleton* Instance();//供外部访问该单件的接口
protected:
Singleton() {};//构造函数，保护起来，防止被意外实例化
private:
static Singleton* __Instance;//用来保存唯一实例
};
Singleton* Singleton::__Instance = NULL;//初始化
Singleton* Singleton::Instance()
{
if (__Instance == NULL)
{
__Instance = new Singleton;
}
return __Instance;
}
void main()
{
Singleton* v1 = Singleton::Instance();
//v1 = 0x000d6a38 {...}
Singleton* v2 = Singleton::Instance();
v2 = 0x000d6a38 {...}和v1指向同一片地址
//Singleton* v3 = new Singleton;//会发出不可访问的错误报告
//Singleton  v4;//会发出不可访问的错误报告
system("pause");
getchar();
}

抽象工厂模式(ABSTRACT FACTORY)：
意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。
动机：生活中我们可能会遇到同样的东西，在具体的不同的领域有不同的表现形式。当提供一个产品类库，只是想显示他们的接口而不是实现时，可以使用抽象工厂。就比如动物吃饭，动物是一个类，但是具体到某一种动物有自己的吃饭方式。
思考：我们如何去做到具体不同的动物类型，去做自己的事情呢？将动物定义为一个抽象类便可以解决。
解决办法：我们定义抽象类之后，客户只需要和抽象类定义的接口交互，而不使用特定的具体类的接口。
代码：

class ProductA//纯虚接口A
{
public:
virtual void Show() = 0;
};

class ProductA1 : public ProductA
{
public:
void Show()
{
cout << "This is ProductA1" << endl;
}
};

class ProductA2 : public ProductA
{
public:
void Show()
{
cout << "This is ProductA2" << endl;
}
};


class ProductB//纯虚接口B
{
public:
virtual void Show() = 0;
};

class ProductB1 : public ProductB
{
public:
void Show()
{
cout << "This is ProductB1" << endl;
}
};

class ProductB2 : public ProductB
{
public:
void Show()
{
cout << "This is ProductB2" << endl;
}
};

class Factory//抽象基类
{
public:
virtual ProductA *CreateProductA() = 0;
virtual ProductB *CreateProductB() = 0;
};

class Factory1 : public Factory//工厂1
{
public:
static Factory1* Instance();
ProductA *CreateProductA()
{
return new ProductA1();
}

ProductB *CreateProductB()
{
return new ProductB1();
}
protected:
Factory1() {};
private:
static Factory1* __Instance1;//保证只有一个实例
};
Factory1* Factory1::__Instance1 = NULL;
Factory1* Factory1::Instance()
{
if (__Instance1 == NULL)
{
__Instance1 = new Factory1();
}
return __Instance1;
}
class Factory2 : public Factory//工厂2
{
public:
static Factory2* Instance();
ProductA *CreateProductA()
{
return new ProductA2();
}

ProductB *CreateProductB()
{
return new ProductB2();
}
protected:
Factory2() {};
private:
static Factory2* __Instance2;//保证只有一个实例
};
Factory2* Factory2::__Instance2 = NULL;
Factory2* Factory2::Instance()
{
if (__Instance2 == NULL)
{
__Instance2 = new Factory2();
}
return __Instance2;
}