本篇内容

class Singleton
{
private:
    static Singleton * pinstance_;  
    static mutex mutex_;  //互斥量

protected:
    Singleton(const string value): value_(value)  
	//构造函数和析构函数设为protected（这样派生类可以访问）
    {
    }
    ~Singleton() {}
    string value_;

public:

    Singleton(Singleton &other) = delete;  //禁用拷贝和赋值

    void operator=(const Singleton &) = delete;

	static Singleton *GetInstance(const string& value);  //返回实例

    void func()  //一些其他功能
    {
        // ...
    }
    
    string value() const{
        return value_;
    } 
};

//静态变量和函数需要在类外定义
Singleton* Singleton::pinstance_{nullptr};
mutex Singleton::mutex_;

Singleton *Singleton::GetInstance(const string& value) 
{
    lock_guard<mutex> lock(mutex_);
    if (pinstance_ == nullptr)
    {
        pinstance_ = new Singleton(value);
    }
    return pinstance_;
}

class Singleton{
private:
    static Singleton* instence;

protected:
	 Singleton(){} 
public:
	Singleton(const Singleton& other) = delete;
	Singleton& operator=(const Singleton& other) = delete;
    static Singleton* getInstence(){ 
        return instence;    
    }
};
Singleton* Singleton::instence = new Singleton(); //直接实例化

//客户端用的接口
class Target {
public:
	virtual ~Target();
	virtual void Request() const
	{
		//....
	}
};

//adaptee的接口和客户端的不兼容，适配器的目标就是让二者可以正常交互。
class Adaptee {
public:
	void SpecificRequest() const
	{
		//...
	}
};


//适配器类，需要继承target和adaptee
class Adapter: public Target, public Adaptee {
public:
	Adapter(){}

	//重写target中的request，让adaptee能看懂target的输出
	void Request() const override{
		//...
	}
	
};

//由于Adapter是Target的派生类，所以函数的输入可以为Adapter。
void ClientCode(const Target *target)
{
	//...
}

//产品
class Product {
 public:
  virtual ~Product() {}
  virtual string Operation() const = 0;
};

//具体产品1
class ConcreteProduct1 : public Product {
 public:
  string Operation() const override {
    return "{Result of the ConcreteProduct1}";
  }
};

//具体产品2
class ConcreteProduct2 : public Product {
 public:
  string Operation() const override {
    return "{Result of the ConcreteProduct2}";
  }
};

//创建者
class Creator {

 public:
  virtual ~Creator(){};
  virtual Product* FactoryMethod() const = 0;

  //实现一些操作
  string SomeOperation() const {
    // Call the factory method to create a Product object.
    Product* product = this->FactoryMethod();
    // Now, use the product.
    string result = "Creator: The same creator's code has just worked with " + product->Operation();
    delete product;
    return result;
  }
};

//具体工厂1，生产产品1
class ConcreteCreator1 : public Creator {

 public:
  Product* FactoryMethod() const override {
    return new ConcreteProduct1();
  }
};


//具体工厂1，生产产品2
class ConcreteCreator2 : public Creator {
 public:
  Product* FactoryMethod() const override {
    return new ConcreteProduct2();
  }
};


void ClientCode(const Creator& creator) {
  // ...
  cout<<creator.SomeOperation()<<endl;
  // ...
}

int main() {
  cout << "App: Launched with the ConcreteCreator1.\n";
  Creator* creator = new ConcreteCreator1();
  ClientCode(*creator);
  cout << endl;
  cout << "App: Launched with the ConcreteCreator2.\n";
  Creator* creator2 = new ConcreteCreator2();
  ClientCode(*creator2);

  delete creator;
  delete creator2;
  return 0;
}

//每种抽象产品都有一个接口
class AbstractProductA {
 public:
  virtual ~AbstractProductA(){};
  virtual string UsefulFunctionA() const = 0; //纯虚函数，在子类中实现
};

//根据抽象产品，构建具体产品类
class ConcreteProductA1 : public AbstractProductA {
 public:
  string UsefulFunctionA() const override {
    return "The result of the product A1.";
  }
};

class ConcreteProductA2 : public AbstractProductA {
  string UsefulFunctionA() const override {
    return "The result of the product A2.";
  }
};

class AbstractProductB {

 public:
  virtual ~AbstractProductB(){};
  virtual string UsefulFunctionB() const = 0;
  //产品之间可以交互
  virtual string AnotherUsefulFunctionB(const AbstractProductA &collaborator) const = 0;
};

class ConcreteProductB1 : public AbstractProductB {
 public:
  string UsefulFunctionB() const override {
    return "The result of the product B1.";
  }

  string AnotherUsefulFunctionB(const AbstractProductA &collaborator) const override {
    const string result = collaborator.UsefulFunctionA();
    return "The result of the B1 collaborating with ( " + result + " )";
  }
};

class ConcreteProductB2 : public AbstractProductB {
 public:
  string UsefulFunctionB() const override {
    return "The result of the product B2.";
  }

  string AnotherUsefulFunctionB(const AbstractProductA &collaborator) const override {
    const string result = collaborator.UsefulFunctionA();
    return "The result of the B2 collaborating with ( " + result + " )";
  }
};

//抽象工厂类声明一系列抽象产品
class AbstractFactory {
 public:
  virtual AbstractProductA *CreateProductA() const = 0;
  virtual AbstractProductB *CreateProductB() const = 0;
};

//具体工厂类生产具体的产品
class ConcreteFactory1 : public AbstractFactory {
 public:
  AbstractProductA *CreateProductA() const override {
    return new ConcreteProductA1();
  }
  AbstractProductB *CreateProductB() const override {
    return new ConcreteProductB1();
  }
};

class ConcreteFactory2 : public AbstractFactory {
 public:
  AbstractProductA *CreateProductA() const override {
    return new ConcreteProductA2();
  }
  AbstractProductB *CreateProductB() const override {
    return new ConcreteProductB2();
  }
};

//客户端调用
void ClientCode(const AbstractFactory &factory) {
  const AbstractProductA *product_a = factory.CreateProductA();
  const AbstractProductB *product_b = factory.CreateProductB();
  cout << product_b->UsefulFunctionB() << "\n";
  cout << product_b->AnotherUsefulFunctionB(*product_a) << "\n";
  delete product_a;
  delete product_b;
}

#include <iostream>
#include <list>
#include <string>
using namespace std;


class IObserver {
 public:
  virtual ~IObserver(){};
  virtual void Update(const string &message_from_subject) = 0;
};

class ISubject {
 public:
  virtual ~ISubject(){};
  virtual void Attach(IObserver *observer) = 0;
  virtual void Detach(IObserver *observer) = 0;
  virtual void Notify() = 0;
};

//subject是一个发布者类
class Subject : public ISubject {
 public:
  virtual ~Subject() {
    cout << "Goodbye, I was the Subject.\n";
  }

  //往订阅列表里新增
  void Attach(IObserver *observer) override {
    list_observer_.push_back(observer);
  }

  //去除订阅者
  void Detach(IObserver *observer) override {
    list_observer_.remove(observer);
  }

  //广播
  void Notify() override {
    list<IObserver *>::iterator iterator = list_observer_.begin();
    HowManyObserver();
    while (iterator != list_observer_.end()) {
      (*iterator)->Update(message_);
      ++iterator;
    }
  }

  //创建信息
  void CreateMessage(string message = "Empty") {
    this->message_ = message;
    Notify();
  }
  void HowManyObserver() {
    cout << "There are " << list_observer_.size() << " observers in the list.\n";
  }


  void SomeBusinessLogic() {
    this->message_ = "change message message";
    Notify();
    cout << "I'm about to do some thing important\n";
  }

 private:
  list<IObserver *> list_observer_;
  string message_;
};

//观察者
class Observer : public IObserver {
 public:
  Observer(Subject &subject) : subject_(subject) {
    this->subject_.Attach(this);
    cout << "Hi, I'm the Observer \"" << ++Observer::static_number_ << "\".\n";
    this->number_ = Observer::static_number_;
  }
  virtual ~Observer() {
    cout << "Goodbye, I was the Observer \"" << this->number_ << "\".\n";
  }

  //获取来自于发布者的信息
  void Update(const string &message_from_subject) override {
    message_from_subject_ = message_from_subject;
    PrintInfo();
  }

  //取消订阅
  void RemoveMeFromTheList() {
    subject_.Detach(this);
    cout << "Observer \"" << number_ << "\" removed from the list.\n";
  }


  void PrintInfo() {
    cout << "Observer \"" << this->number_ << "\": a new message is available --> " << this->message_from_subject_ << "\n";
  }

 private:
  string message_from_subject_;
  Subject &subject_;
  static int static_number_;
  int number_;
};

int Observer::static_number_ = 0;

void ClientCode() {
  Subject *subject = new Subject;
  Observer *observer1 = new Observer(*subject);
  Observer *observer2 = new Observer(*subject);
  Observer *observer3 = new Observer(*subject);
  Observer *observer4;
  Observer *observer5;

  subject->CreateMessage("Hello World! :D");
  observer3->RemoveMeFromTheList();

  subject->CreateMessage("The weather is hot today! :p");
  observer4 = new Observer(*subject);

  observer2->RemoveMeFromTheList();
  observer5 = new Observer(*subject);

  subject->CreateMessage("My new car is great! ;)");
  observer5->RemoveMeFromTheList();

  observer4->RemoveMeFromTheList();
  observer1->RemoveMeFromTheList();

  delete observer5;
  delete observer4;
  delete observer3;
  delete observer2;
  delete observer1;
  delete subject;
}