设计模式( 一 )

常见的创建型设计模式

1.单例模式 : 确保一个类只有一个实例 , 为整个程序提供一个全局的访问接口。getInstance

实现方式

• 饿汉式，在调用getInstance 创建实例的时候 ，实例已经存在了 ，不需要我们再次去 new创建。
  优点： 实现简单 ， 在多线程的环境下是线程安全的。

class Singleton {public:static Singleton* getInstance() {return singleton.get();   // 返回管理的原始指针}~Singleton() { cout << __FUNCTION__ << endl;  }private:Singleton() { cout << __FUNCTION__ << endl; }Singleton(const Singleton& other) = delete;Singleton& operator =(const Singleton& other) = delete;static unique_ptr< Singleton >singleton;  // 用智能指针来托管这个有生命周期的对象.避免我们手动去释放};unique_ptr< Singleton>Singleton::singleton( new Singleton);

• 懒汉式，第一次使用的时候, 才初始化实例
  缺点: 不适合多线程环境( 如果要在多线程下使用 ,需要加锁 )
  优点: 节省资源

  // 利用C++11的新特性 线程安全且简单#include <mutex>class Singleton {public:static Singleton* getInstance() {call_once(flag, []() {   // 保存对象只 new 一次singleton.reset(new Singleton);});return singleton.get(); // 返回管理的原始指针}~Singleton() { cout << __FUNCTION__ << endl; }private:Singleton() { cout << __FUNCTION__ << endl; }Singleton(const Singleton& other) = delete;Singleton& operator =(const Singleton& other) = delete;static unique_ptr<Singleton>singleton;static once_flag flag;};unique_ptr< Singleton>Singleton::singleton;once_flag Singleton::flag;// 其他的写法 ,可以参考class Singleton {public:static Singleton* getInstance() {statict Singleton singleton;return &singleton;}private:Singleton() { cout << __FUNCTION__ << endl; }~Singleton() { cout << __FUNCTION__ << endl; }Singleton(const Singleton& other) = delete;Singleton& operator =(const Singleton& other) = delete;};

适用场景 : 线程池 、系统日志、内存池。等等

2.简单工厂模式: 定义一个工厂类 , 用来创建不同类型的对象实例 .
目的: 将对象创建的过程封装在工厂类里面 , 我们只需要调用工厂类的生产方法 ,而不需要关心具体的实现过程.
基本结构

• 工厂类 —>用于创建对象的实例
• 产品类 —> 创建对象的父类
• 具体产品类----> 继承产品类 , 重写父类的virtual 方法.

具体实现方法:

// 产品类
class Animal {
public:Animal() { }; virtual void eat() = 0;virtual void drinking() = 0;virtual ~Animal( ) { }
};// 具体产品类
class Dog :public Animal {
public:Dog() { }virtual ~Dog() { }virtual void eat() { std::cout << "++ Dog eat" << std::endl; }virtual void drinking() { std::cout << "++ Dog drinking" << std::endl; }
};// 具体产品类
class Cat :public Animal {
public:Cat() { }virtual ~Cat() { }virtual void eat() { std::cout << "++ Cat eat" << std::endl; }virtual void drinking() { std::cout << "++ Cat drinking" << std::endl; }
};// 具体产品类
class Beef :public Animal {
public:Beef() { }virtual ~Beef() { }virtual void eat() { std::cout << "++ Beef eat" << std::endl;  }virtual void drinking() { std::cout << "++ Beef drinking" << std::endl;  }
};// 产品类型
enum class AnimalType :char
{Dog,Cat,Beef
};// 工厂类
class Factory {
public:Factory() { };~Factory() { };// 生产Animal* make_animal( AnimalType  type ) {Animal* animal = nullptr;switch ( type ){case AnimalType::Cat:animal = new Cat;break;case AnimalType::Dog:animal = new Dog;break;case AnimalType::Beef:animal = new Beef;break;default:break;}return animal;}
};int main( ) {// 创建一个工厂实例 , 调用生产方法 ,生成我们需要的产品.Factory factory;   Animal* Beef = factory.make_animal(AnimalType::Beef);Beef->drinking();Animal* Dog = factory.make_animal(AnimalType::Dog);Dog->eat();system("pause");return 0;
}

适用场景： 创建对象的逻辑较为简单、对象类型较少。

3.工厂模式: 它定义了一个创建对象的工厂，但由工厂的子类决定生成哪一个产品。
基本结构：

• 工厂类 —>定义生产产品的接口
• 具体工厂类—>继承工厂类 ， 对生产接口进行具体实现。返回具体的产品实例
• 产品类—>定义产品的父类
• 具体产品类 —> 继承产品类 ，实现产品类的具体方法。

具体的实现：

// 产品类
class Animal {
public:Animal() { }; virtual void eat() = 0;virtual void drinking() = 0;virtual ~Animal( ) { }
};// 具体产品类
class Dog :public Animal {
public:Dog() { }virtual ~Dog() { }virtual void eat() { std::cout << "++ Dog eat" << std::endl; }virtual void drinking() { std::cout << "++ Dog drinking" << std::endl; }
};// 具体产品类
class Cat :public Animal {
public:Cat() { }virtual ~Cat() { }virtual void eat() { std::cout << "++ Cat eat" << std::endl; }virtual void drinking() { std::cout << "++ Cat drinking" << std::endl; }
};// 具体产品类
class Beef :public Animal {
public:Beef() { }virtual ~Beef() { }virtual void eat() { std::cout << "++ Beef eat" << std::endl;  }virtual void drinking() { std::cout << "++ Beef drinking" << std::endl;  }
};// 工厂类
class AbstractFactory {
public:AbstractFactory() { };virtual ~AbstractFactory() { };// 生产virtual Animal* make_animal( ) = 0;
};// 具体工厂类
class DogFactory : public AbstractFactory {
public:DogFactory() { }virtual ~DogFactory() { }virtual Animal* make_animal() {return new Dog;}
};// 具体工厂类
class CatFactory : public AbstractFactory {
public:CatFactory() { }virtual ~CatFactory() { }virtual Animal* make_animal() {return new Cat;}
};// 具体工厂类
class BeefFactory : public AbstractFactory {
public:BeefFactory() { }virtual ~BeefFactory() { }virtual Animal* make_animal() {return new Beef;}
};int main( ) {// 创建一个狗的工厂 ，用于生产狗AbstractFactory  *factory_dog = new DogFactory;Animal* dog = factory_dog->make_animal();dog->eat();// 创建一个猫的工厂 ，用于生产猫AbstractFactory* factory_cat = new CatFactory;Animal* cat = factory_cat->make_animal();cat->drinking();system("pause");return 0;
}

工厂模式是对简单工厂模式的优化 ， 将生产产品的的过程延申到工厂的子类中进行实现 ， 提高程序的可扩展性。

4.抽象工厂模式: 提供一系列创建产品的接口 , 无需指定具体的类.

适用于: 生产的产品结构比较复杂的类, 入电脑 , 汽车( 由很多零部件构成 , 而同一个零部件又有很多类型).

基本结构:

• 抽象工厂—> 定义创建产品的方法.
• 具体工厂—> 实现创建产品的方法 , 这些方法会返回一个具体的产品.
• 抽象产品 —> 为每种产品声明一个接口.
• 具体产品 —> 实现抽象产品的接口.
• 客户端 —> 通过抽象工厂和抽象产品来生产产品.

例如: 建造一海贼艘船

|---------------------- --基础版-----------------豪华版----------------旗舰版 |
| 动力系统------------船桨--------------------内燃机----------------核动力 |
| 防御系统------------防空机枪--------------反舰导弹-------------激光炮 |
| 创建材料------------木头--------------------钢铁-------------------合金 |

具体实现:

#include <iostream>
#include <string>// 动力系统抽象类
class AbstractPower {
public:AbstractPower() {  }virtual ~AbstractPower( ) { }virtual std::string getPower() = 0;
};// 船桨动力
class BodyPower : public AbstractPower {
public:BodyPower() { }virtual ~BodyPower() { }virtual std::string getPower() {return std::string("< 船桨>动力系统");}
};// 内燃机
class EnginePower : public AbstractPower {
public:EnginePower() { }virtual ~EnginePower() { }virtual std::string getPower() {return std::string("< 内燃机>动力系统");}
};// 核动力
class EnergyPower : public AbstractPower {
public:EnergyPower() { }virtual ~EnergyPower() { }virtual std::string getPower() {return std::string("< 核能>动力系统");}
};// 防御系统抽象类
class AbstractDefense {
public:AbstractDefense() { }virtual ~AbstractDefense() { }virtual std::string getDefense() = 0;
};// 防空机枪
class Gun : public AbstractDefense {
public:Gun() { }virtual ~Gun() { }virtual std::string getDefense() {return std::string("<防空机枪>防御系统");}
};// 反舰导弹
class Guided : public AbstractDefense {
public:Guided() { }virtual ~Guided() { }virtual std::string getDefense() {return std::string("<防空导弹>防御系统");}
};// 激光炮
class Laser : public AbstractDefense {
public:Laser() { }virtual ~Laser() { }virtual std::string getDefense() {return std::string("<激光炮>防御系统");}
};// 建造材料抽象类
class AbstractMaterials {
public:AbstractMaterials() { }virtual ~AbstractMaterials() { }virtual std::string getMaterials() = 0;
};// 木头
class Wood :public AbstractMaterials {
public:Wood() { }virtual ~Wood() { }virtual std::string getMaterials() {return std::string("<木头>建造");}
};// 钢铁
class Steel :public AbstractMaterials {
public:Steel() { }virtual ~Steel() { }virtual std::string getMaterials() {return std::string("<钢铁>建造");}
};// 合金
class Alloy :public AbstractMaterials {
public:Alloy() { }virtual ~Alloy() { }virtual std::string getMaterials() {return std::string("<合金>建造");}
};// 船
class Shop {
public:Shop(AbstractPower* power, AbstractDefense* defence, AbstractMaterials* materials):power_(power), defence_(defence), materials_( materials ){  }~Shop( ) { delete power_;delete defence_;delete materials_;}std::string getShopInforamtion() {std::string info = power_->getPower() + defence_->getDefense() + materials_->getMaterials();return info;}
private:AbstractPower* power_;         // 动力系统AbstractDefense* defence_;     // 防御系统AbstractMaterials* materials_;  // 建造材料
};// 工厂抽象类
class AbstractFactory {
public:AbstractFactory( ) { }virtual ~AbstractFactory() { }virtual Shop* CreateShop() = 0;
};class BasicShop :public AbstractFactory {
public:BasicShop( ) { }virtual ~BasicShop( ){ }virtual Shop* CreateShop() {Shop* shop = new Shop(new BodyPower, new Gun, new Wood);std::cout << "<基础形>海贼船建造完毕" << std::endl;return shop;}
};// 
class LuxuryShop :public AbstractFactory {
public:LuxuryShop() { }virtual ~LuxuryShop() { }virtual Shop* CreateShop() {Shop* shop = new Shop(new EnginePower, new Guided, new Steel);std::cout << "<豪华型>海贼船建造完毕" << std::endl;return shop;}
};class FlagshipShop :public AbstractFactory {
public:FlagshipShop() { }virtual ~FlagshipShop() { }virtual Shop* CreateShop() {Shop* shop = new Shop( new EnergyPower , new Laser, new Alloy);std::cout << "<旗舰型>海贼船建造完毕" << std::endl;return shop;}
};int main() {AbstractFactory* factory = new BasicShop;Shop *shop = factory->CreateShop();std::cout << shop->getShopInforamtion() << std::endl;return 0;
}

效果演示: