设计模式--创建型

简单工厂实现

#include <iostream>
#include <memory>

// 抽象产品类
class Product {
  public:
      virtual ~Product() {}
      virtual void Operation() const = 0;
};

// 具体产品 类A
class ConcreteProductA : public Product {
  public:
      virtual void Operation() const override {
	      std::cout << "Product A" << std::endl;
	  }
};

// 具体产品 类B
class ConcreteProductB : public Product {
  public:
      virtual void Operation() const override {
	      std::cout << "Product B" << std::endl;
	  }
};

enum class ProductType: uint8_t {
    ProductA = 0,
    ProductB = 1
};

// 工厂类
class Factory {
   public:
    Product *CreateProduct(enum ProductType type) const {
        switch(type) {
            case ProductType::ProductA:
                return new ConcreteProductA;
            case ProductType::ProductB:
                return new ConcreteProductB;
            default:
                throw std::invalid_argument("Invalid product type");
        }
    }	
};

int main(int argc, char **argv)
{
	Factory factory;
	// 创建产品 A
	ConcreteProductA *productA = reinterpret_cast<ConcreteProductA*>(factory.CreateProduct(ProductType::ProductA));
    productA->Operation();
    delete productA;

    // 创建产品 B
    ConcreteProductB* productB = reinterpret_cast<ConcreteProductB*>(factory.CreateProduct(ProductType::ProductB));
    productB->Operation();
    delete productB;
    
    return 0;
}

工厂方法实现

#include <iostream>
#include <memory>

// 抽象产品类
class Product {
  public:
      virtual ~Product() {}
      virtual void Operation() const = 0;
};

// 具体产品 类A
class ConcreteProductA : public Product {
  public:
      virtual void Operation() const override {
	      std::cout << "Product A" << std::endl;
	  }
};

// 具体产品 类B
class ConcreteProductB : public Product {
  public:
      virtual void Operation() const override {
	      std::cout << "Product B" << std::endl;
	  }
};

// 抽象工厂类
class Factory {
   public:
    virtual ~Factory(){}
    virtual Product *CreateProduct() = 0;	
};

// A类工厂
class ProductAFactory: public Factory  {
  public:
    virtual Product *CreateProduct() override {
        return new ConcreteProductA();
    }
};

// B类工厂
class ProductBFactory: public Factory  {
  public:
    virtual Product *CreateProduct() override {
        return new ConcreteProductB();
    }
};

int main(int argc, char **argv)
{
    Factory *a_factory = new ProductAFactory();
    Factory *b_factory = new ProductBFactory();

    auto a_product = a_factory->CreateProduct();
    auto b_product = b_factory->CreateProduct();

    a_product->Operation();
    b_product->Operation();

    delete a_product;
    delete b_product;

    delete a_factory;
    delete b_factory;

    return 0;
}

抽象工厂实现

#include <iostream>
#include <memory>

// 抽象产品A类
class ProductA {
  public:
      virtual ~ProductA() {}
      virtual void Operation() const = 0;
};

// 具体产品 类A
class ConcreteProductA : public ProductA {
  public:
      virtual void Operation() const override {
	      std::cout << "Product A" << std::endl;
	  }
};

//  抽象产品B类
class ProductB {
  public:
      virtual ~ProductB() {}
      virtual void Operation() const = 0;
};

// 具体产品 类B
class ConcreteProductB : public ProductB {
  public:
      virtual void Operation() const override {
	      std::cout << "Product B" << std::endl;
	  }
};

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

// 具体工厂类
class ConcreteFactory1: public Factory  {
  public:
    virtual ProductA *CreateProductA() override {
        return new ConcreteProductA();
    }

    virtual ProductB *CreateProductB() override {
        return new ConcreteProductB();
    }
};

class ConcreteFactory2: public Factory  {
  public:
    virtual ProductA *CreateProductA() override {
        return new ConcreteProductA();
    }

    virtual ProductB *CreateProductB() override {
        return new ConcreteProductB();
    }
};

int main(int argc, char **argv)
{
    Factory *a_factory = new ConcreteFactory1();
    Factory *b_factory = new ConcreteFactory2();

    auto a_producta = a_factory->CreateProductA();
    auto a_productb = a_factory->CreateProductB();

    auto b_producta = b_factory->CreateProductA();
    auto b_productb = b_factory->CreateProductB();

    a_producta->Operation();
    a_productb->Operation();

    b_producta->Operation();
    b_productb->Operation();


    delete a_producta;
    delete a_productb;

    delete b_producta;
    delete b_productb;

    delete a_factory;
    delete b_factory;

    return 0;
}

#include <iostream>
#include <string>

// 产品类
class Computer
{
  public:
    Computer(const std::string& brand)
    {
        brand_ = brand;
    }
    void SetCpu(std::string cpu)
    {
        cpu_ = cpu;
    }
    void SetMainboard(std::string mainboard)
    {
        mainboard_ = mainboard;
    }
    void SetRam(std::string ram)
    {
        ram_ = ram;
    }
    void SetVideoCard(std::string videoCard)
    {
        video_card_ = videoCard;
    }

    void show() const
    {
        std::cout << "build an computer with: " << std::endl;
        std::cout << "                 Brand: " << brand_ << std::endl;  // 展示所组装的电脑
        std::cout << "                   CPU: " << cpu_ << std::endl;
        std::cout << "             Mainboard: " << mainboard_ << std::endl;
        std::cout << "                   Ram: " << ram_ << std::endl;
        std::cout << "             VideoCard: " << video_card_ << std::endl;
    }

  private:
    std::string brand_;
    std::string cpu_;
    std::string mainboard_;
    std::string ram_;
    std::string video_card_;
};

/**
 * @brief 建造者接口，组装流程
 *
 */
class IBuilder
{
  public:
    virtual void      BuildCpu()       = 0;
    virtual void      BuildMainboard() = 0;
    virtual void      BuildRam()       = 0;
    virtual void      BuildVideoCard() = 0;
    virtual Computer* GetResult()      = 0;
};

// 具体的建筑者类：ThinkPad
class ThinkPadBuilder : public IBuilder
{
  public:
    ThinkPadBuilder()
    {
        computer_ = new Computer("ThinkPad");
    }
    void BuildCpu() override
    {
        computer_->SetCpu("Intel 酷睿i5 5200U");
    }

    void BuildMainboard() override
    {
        computer_->SetMainboard("Intel DH57DD");
    }
    void BuildRam() override
    {
        computer_->SetRam("DDR4");
    }
    void BuildVideoCard() override
    {
        computer_->SetVideoCard("AMD Radeon R7 M260");
    }
    Computer* GetResult() override
    {
        return computer_;
    }

  private:
    Computer* computer_;
};

// 具体的建筑者类：Yoga
class AlienwareBuilder : public IBuilder
{
  public:
    AlienwareBuilder()
    {
        computer_ = new Computer("Alienware");
    }
    void BuildCpu() override
    {
        computer_->SetCpu("i7-7500U");
    }
    void BuildMainboard() override
    {
        computer_->SetMainboard("Intel DP55KG");
    }
    void BuildRam() override
    {
        computer_->SetRam("DDR5");
    }
    void BuildVideoCard() override
    {
        computer_->SetVideoCard("NVIDIA GeForce RTX 4070 8GB GDDR6");
    }
    Computer* GetResult() override
    {
        return computer_;
    }

  private:
    Computer* computer_;
};

/**
 * @brief 指挥者类
 *
 */
class Direcror
{
  public:
    void Create(IBuilder* builder)
    {
        builder->BuildCpu();
        builder->BuildMainboard();
        builder->BuildRam();
        builder->BuildVideoCard();
    }
};

int main()
{
    Direcror*         pDirecror         = new Direcror();
    ThinkPadBuilder*  pTPBuilder        = new ThinkPadBuilder();
    AlienwareBuilder* pAlienwareBuilder = new AlienwareBuilder();

    pDirecror->Create(pTPBuilder);
    pDirecror->Create(pAlienwareBuilder);

    // 获取组装后的电脑
    Computer* pThinkPadComputer  = pTPBuilder->GetResult();
    Computer* pAlienwareComputer = pAlienwareBuilder->GetResult();

    // 测试输出
    pThinkPadComputer->show();
    std::cout << "====================================" << std::endl;
    pAlienwareComputer->show();

    delete pDirecror;
    delete pTPBuilder;
    delete pAlienwareBuilder;

    delete pThinkPadComputer;
    delete pAlienwareComputer;

    return 0;
}

#include <iostream>
#include <memory>

class LazySingleton
{
  public:
    static LazySingleton& GetInstance()
    {
        static LazySingleton single;
        return single;
    }

    void Print()
    {
        std::cout << "Instance addr:" << this << std::endl;
    }

  private:
    LazySingleton()
    {
        std::cout << "LazySingleton()" << std::endl;
    }

    ~LazySingleton()
    {
        std::cout << "~LazySingleton" << std::endl;
    }

    LazySingleton(const LazySingleton& LazySingleton)                  = delete;
    const LazySingleton& operator=(const LazySingleton& LazySingleton) = delete;
};

class HungrySingleton
{
  public:
    // 获取单实例对象
    static HungrySingleton &GetInstance()
    {
        return single_;
    }

    void Print()
    {
        std::cout << "Instance addr:" << this << std::endl;
    }

  private:
    HungrySingleton()
    {
        std::cout << "HungrySingleton()" << std::endl;
    }

    ~HungrySingleton()
    {
        std::cout << "~HungrySingleton" << std::endl;
    }

    HungrySingleton(const HungrySingleton& LazySingleton)                  = delete;
    const HungrySingleton& operator=(const HungrySingleton& LazySingleton) = delete;

  private:
    static HungrySingleton single_;
};

HungrySingleton HungrySingleton::single_;

int main(int argc, char** argv)
{
    std::cout << "===================beigin LazySingleton =================" << std::endl;
    LazySingleton::GetInstance().Print();
    LazySingleton::GetInstance().Print();
    LazySingleton::GetInstance().Print();
    LazySingleton::GetInstance().Print();
    LazySingleton::GetInstance().Print();

    std::cout << "===================beigin HungrySingleton =================" << std::endl;
    HungrySingleton::GetInstance().Print();
    HungrySingleton::GetInstance().Print();
    HungrySingleton::GetInstance().Print();
    HungrySingleton::GetInstance().Print();
    HungrySingleton::GetInstance().Print();

    return 0;
}

输出

HungrySingleton().   // 类的加载时实例化
===================beigin LazySingleton =================
LazySingleton() // 首次使用时实例化
Instance addr:0x10af6f000
Instance addr:0x10af6f000
Instance addr:0x10af6f000
Instance addr:0x10af6f000
Instance addr:0x10af6f000
===================beigin HungrySingleton =================
Instance addr:0x10af6f010
Instance addr:0x10af6f010
Instance addr:0x10af6f010
Instance addr:0x10af6f010
Instance addr:0x10af6f010
~LazySingleton
~HungrySingleton