C++ 设计模式

#include <iostream>
#include <memory>
class Pizza {
public:
  void setDough(const std::string &dough) { m_dough = dough; }
  void setSauce(const std::string &sauce) { m_sauce = sauce; }
  void setTopping(const std::string &topping) { m_topping = topping; }
  void open() const {
    std::cout << "The Pizza have " << m_dough << " dough, " << m_sauce
              << " sauce, " << m_topping << " topping." << std::endl;
  }

private:
  std::string m_dough;
  std::string m_sauce;
  std::string m_topping;
};

class PizzaBuilder {
public:
  virtual ~PizzaBuilder() = default;
  void createNewPizza() { m_pizza = std::make_unique<Pizza>(); }
  Pizza *getPizza() { return m_pizza.release(); }
  virtual void buildDough() = 0;
  virtual void buildSauce() = 0;
  virtual void buildTopping() = 0;

protected:
  std::unique_ptr<Pizza> m_pizza;
};

class HawaiianPizzaBuilder : public PizzaBuilder {
public:
  ~HawaiianPizzaBuilder() override = default;
  void buildDough() override { m_pizza->setDough("Hawaiian dough"); }
  void buildSauce() override { m_pizza->setSauce("Hawaiian sauce"); }
  void buildTopping() override { m_pizza->setTopping("Hawaiian topping"); }
};

class SpicyPizzaBuilder : public PizzaBuilder {
public:
  ~SpicyPizzaBuilder() override = default;
  void buildDough() override { m_pizza->setDough("Spicy dough"); }
  void buildSauce() override { m_pizza->setSauce("Spicy sauce"); }
  void buildTopping() override { m_pizza->setTopping("Spicy topping"); }
};

class Cook {
public:
  void openPizza() const { m_pizzaBuilder->getPizza()->open(); }
  void createPizza(PizzaBuilder *pizzaBuilder) {
    m_pizzaBuilder = pizzaBuilder;
    m_pizzaBuilder->createNewPizza();
    m_pizzaBuilder->buildDough();
    m_pizzaBuilder->buildSauce();
    m_pizzaBuilder->buildTopping();
  }

private:
  PizzaBuilder *m_pizzaBuilder;
};

int main() {
  Cook cook{};
  HawaiianPizzaBuilder hawaiianPizzaBuilder;
  cook.createPizza(&hawaiianPizzaBuilder);
  cook.openPizza();

  SpicyPizzaBuilder spicyPizzaBuilder;
  cook.createPizza(&spicyPizzaBuilder);
  cook.openPizza();
}
// 输出
// The Pizza have Hawaiian dough dough, Hawaiian sauce sauce, Hawaiian topping
// topping. The Pizza have Spicy dough dough, Spicy sauce sauce, Spicy topping
// topping.

class Computer {
public:
  virtual void Run() = 0;
  virtual void Stop() = 0;

  virtual ~Computer(){}; // 若无该行，该例中无法正确调用其继承类的构造函数
};
class Laptop : public Computer {
public:
  void Run() override { mHibernating = false; };
  void Stop() override { mHibernating = true; };
  virtual ~Laptop(){}; 
private:
  bool mHibernating; // 该设备正在 hibernate
};
class Desktop : public Computer {
public:
  void Run() override { mOn = true; };
  void Stop() override { mOn = false; };
  virtual ~Desktop(){};

private:
  bool mOn; // 该设备是否启动
};

class ComputerFactory {
public:
  static Computer *NewComputer(const std::string &description) {
    if (description == "laptop")
      return new Laptop;
    if (description == "desktop")
      return new Desktop;
    return nullptr;
  }
};

#include <iostream>
#include <memory>
#include <stdexcept>
using namespace std;

class Pizza {
public:
  virtual int getPrice() const = 0;
  virtual ~Pizza(){};
};

class HamAndMushroomPizza : public Pizza {
public:
  virtual int getPrice() const { return 850; };
  virtual ~HamAndMushroomPizza(){};
};

class DeluxePizza : public Pizza {
public:
  virtual int getPrice() const { return 1050; };
  virtual ~DeluxePizza(){};
};

class HawaiianPizza : public Pizza {
public:
  virtual int getPrice() const { return 1150; };
  virtual ~HawaiianPizza(){};
};

class PizzaFactory {
public:
  enum PizzaType { HamMushroom, Deluxe, Hawaiian };

  static unique_ptr<Pizza> createPizza(PizzaType pizzaType) {
    switch (pizzaType) {
    case HamMushroom:
      return make_unique<HamAndMushroomPizza>();
    case Deluxe:
      return make_unique<DeluxePizza>();
    case Hawaiian:
      return make_unique<HawaiianPizza>();
    }
    throw "invalid pizza type.";
  }
};

/*
 * Create all available pizzas and print their prices
 */
void pizza_information(PizzaFactory::PizzaType pizzatype) {
  unique_ptr<Pizza> pizza = PizzaFactory::createPizza(pizzatype);
  cout << "Price of " << pizzatype << " is " << pizza->getPrice() << std::endl;
}

int main() {
  pizza_information(PizzaFactory::HamMushroom);
  pizza_information(PizzaFactory::Deluxe);
  pizza_information(PizzaFactory::Hawaiian);
}

#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>
using namespace std;

// Record 是原型基类
class Record {
public:
  virtual ~Record() {}
  virtual void print() = 0;
  virtual unique_ptr<Record> clone() = 0;
};

// CarRecord 是一个实类原型
class CarRecord : public Record {
private:
  string m_carName;
  int m_ID;

public:
  CarRecord(string carName, int ID) : m_carName(carName), m_ID(ID) {}

  void print() override {
    cout << "Car Record" << endl
         << "Name  : " << m_carName << endl
         << "Number: " << m_ID << endl
         << endl;
  }

  unique_ptr<Record> clone() override { return make_unique<CarRecord>(*this); }
};

class BikeRecord : public Record {
private:
  string m_bikeName;
  int m_ID;

public:
  BikeRecord(string bikeName, int ID) : m_bikeName(bikeName), m_ID(ID) {}

  void print() override {
    cout << "Bike Record" << endl
         << "Name  : " << m_bikeName << endl
         << "Number: " << m_ID << endl
         << endl;
  }

  unique_ptr<Record> clone() override { return make_unique<BikeRecord>(*this); }
};

class PersonRecord : public Record {
private:
  string m_personName;
  int m_age;

public:
  PersonRecord(string personName, int age)
      : m_personName(personName), m_age(age) {}

  void print() override {
    cout << "Person Record" << endl
         << "Name : " << m_personName << endl
         << "Age  : " << m_age << endl
         << endl;
  }

  unique_ptr<Record> clone() override {
    return make_unique<PersonRecord>(*this);
  }
};

// 不透明的 Record 类型，避免直接暴露实现
enum RecordType { CAR, BIKE, PERSON };

// RecordFactory 为客户
class RecordFactory {
private:
  unordered_map<RecordType, unique_ptr<Record>, hash<int>> m_records;

public:
  RecordFactory() {
    m_records[CAR] = make_unique<CarRecord>("Ferrari", 5050);
    m_records[BIKE] = make_unique<BikeRecord>("Yamaha", 2525);
    m_records[PERSON] = make_unique<PersonRecord>("Tom", 25);
  }

  unique_ptr<Record> createRecord(RecordType recordType) {
    return m_records[recordType]->clone();
  }
};

int main() {
  RecordFactory recordFactory;

  auto record = recordFactory.createRecord(CAR);
  record->print();

  record = recordFactory.createRecord(BIKE);
  record->print();

  record = recordFactory.createRecord(PERSON);
  record->print();
}

class CPrototypeMonster {
protected:
  CString _name;

public:
  CPrototypeMonster();
  CPrototypeMonster(const CPrototypeMonster &copy);
  virtual ~CPrototypeMonster();

  virtual CPrototypeMonster *
  Clone() const = 0; // This forces every derived class to provide an override
                     // for this function.
  void Name(CString name);
  CString Name() const;
};

class CGreenMonster : public CPrototypeMonster {
protected:
  int _numberOfArms;
  double _slimeAvailable;

public:
  CGreenMonster();
  CGreenMonster(const CGreenMonster &copy);
  ~CGreenMonster();

  virtual CPrototypeMonster *Clone() const;
  void NumberOfArms(int numberOfArms);
  void SlimeAvailable(double slimeAvailable);

  int NumberOfArms() const;
  double SlimeAvailable() const;
};

class CPurpleMonster : public CPrototypeMonster {
protected:
  int _intensityOfBadBreath;
  double _lengthOfWhiplikeAntenna;

public:
  CPurpleMonster();
  CPurpleMonster(const CPurpleMonster &copy);
  ~CPurpleMonster();

  virtual CPrototypeMonster *Clone() const;

  void IntensityOfBadBreath(int intensityOfBadBreath);
  void LengthOfWhiplikeAntenna(double lengthOfWhiplikeAntenna);

  int IntensityOfBadBreath() const;
  double LengthOfWhiplikeAntenna() const;
};

class CBellyMonster : public CPrototypeMonster {
protected:
  double _roomAvailableInBelly;

public:
  CBellyMonster();
  CBellyMonster(const CBellyMonster &copy);
  ~CBellyMonster();

  virtual CPrototypeMonster *Clone() const;

  void RoomAvailableInBelly(double roomAvailableInBelly);
  double RoomAvailableInBelly() const;
};

CPrototypeMonster *CGreenMonster::Clone() const {
  return new CGreenMonster(*this);
}

CPrototypeMonster *CPurpleMonster::Clone() const {
  return new CPurpleMonster(*this);
}

CPrototypeMonster *CBellyMonster::Clone() const {
  return new CBellyMonster(*this);
}

void DoSomeStuffWithAMonster(const CPrototypeMonster *originalMonster) {
  CPrototypeMonster *newMonster = originalMonster->Clone();
  ASSERT(newMonster);

  newMonster->Name("MyOwnMonster");
  // Add code doing all sorts of cool stuff with the monster.
  delete newMonster;
}

#include <memory>
#include <string>

class StringSingleton {
public:
  // 类自身的一些访问函数
  std::string GetString() const { return mString; }
  void SetString(const std::string &newStr) { mString = newStr; }

  // 该静态函数允许从任何地方访问，欲获取该类的实例，可调用：
  //     StringSingleton::Instance().GetString();
  static StringSingleton &Instance() {
    // 这一行仅运行一次，保证仅创建单个对象
    static auto instance = std::make_unique<StringSingleton>();
    // 对指针取值，使调用者不必使用方向操作符，也可以避免调用者尝试删除变量（笑
    return *instance; // 永远返回同一实例
  }

private:
  // 需要将默认函数私有化避免被客户调用
  StringSingleton() {} // 默认的构造函数只对成员和友元类可见

  // 禁止调用以下两个函数
  StringSingleton(const StringSingleton &old) = delete;
  const StringSingleton &operator=(const StringSingleton &old) = delete;

  // 一些编译器可能不会默认将析构函数私有，这样可以防止客户删除
  ~StringSingleton() {}

private:
  std::string mString;
};

#include <iostream>
using namespace std;

// Mutex 实现
class Mutex {};

// 锁的实现
class Lock {
public:
  Lock(Mutex &m) : mutex(m) { // 获得锁的实现
  }
  ~Lock() { // 释放锁的实现
  }

private:
  Mutex &mutex;
};

class Singleton {
public:
  static Singleton *GetInstance();
  int a;
  ~Singleton() { cout << "In Destructor" << endl; }

private:
  Singleton(int _a) : a(_a) { cout << "In Constructor" << endl; }

  static Mutex mutex;

  Singleton(const Singleton &);
  Singleton &operator=(const Singleton &other);
};

Mutex Singleton::mutex;

Singleton *Singleton::GetInstance() {
  Lock lock(mutex);

  cout << "Get Instance" << endl;

  // 第一次被访问时初始化
  static Singleton inst(1);

  return &inst;
}

int main() {
  Singleton *singleton = Singleton::GetInstance();
  cout << "The value of the singleton: " << singleton->a << endl;
  return 0;
}

#include <iostream>

class Dog { // 抽象目标
public:
  virtual ~Dog() = default;
  virtual void performsConversion() const = 0;
};

class DogFemale : public Dog { // 实现实体目标
public:
  virtual void performsConversion() const override {
    std::cout << "Dog female performs conversion." << std::endl;
  }
};

class Cat { // 抽象适配者
public:
  virtual ~Cat() = default;
  virtual void performsConversion() const = 0;
};

class CatFemale : public Cat {
public:
  virtual void performsConversion() const override {
    std::cout << "Cat female performs conversion." << std::endl;
  }
};

class DogNature {
public:
  void carryOutNature(Dog *dog) {
    std::cout << "On with the Dog nature!" << std::endl;
    dog->performsConversion();
  }
};

class ConversionAdapter : public Dog { // 适配者
private:
  Cat *cat;

public:
  ConversionAdapter(Cat *c) : cat(c) {}
  virtual void performsConversion() const override {
    cat->performsConversion();
  }
};

int main() { // 用户代码
  DogFemale *dogFemale = new DogFemale;
  CatFemale *catFemale = new CatFemale;
  DogNature dogNature;
  //	dogNature.carryOutNature (catFemale);
  //	当然，无法编译由于其接收的类型必须为 Dog*
  ConversionAdapter *adaptedCat =
      new ConversionAdapter(catFemale); // catFemale 被适配为 Dog

  dogNature.carryOutNature(dogFemale);
  dogNature.carryOutNature(adaptedCat);

  delete adaptedCat;
  delete catFemale;
  delete dogFemale;
  return 0;
}

#include <iostream>

using namespace std;

/* Implementor*/
class DrawingAPI {
public:
  virtual void drawCircle(double x, double y, double radius) = 0;
  virtual ~DrawingAPI() {}
};

/* Concrete ImplementorA*/
class DrawingAPI1 : public DrawingAPI {
public:
  void drawCircle(double x, double y, double radius) {
    cout << "API1.circle at " << x << ':' << y << ' ' << radius << endl;
  }
};

/* Concrete ImplementorB*/
class DrawingAPI2 : public DrawingAPI {
public:
  void drawCircle(double x, double y, double radius) {
    cout << "API2.circle at " << x << ':' << y << ' ' << radius << endl;
  }
};

/* Abstraction*/
class Shape {
public:
  virtual ~Shape() {}
  virtual void draw() = 0;
  virtual void resizeByPercentage(double pct) = 0;
};

/* Refined Abstraction*/
class CircleShape : public Shape {
public:
  CircleShape(double x, double y, double radius, DrawingAPI *drawingAPI)
      : m_x(x), m_y(y), m_radius(radius), m_drawingAPI(drawingAPI) {}
  void draw() { m_drawingAPI->drawCircle(m_x, m_y, m_radius); }
  void resizeByPercentage(double pct) { m_radius *= pct; }

private:
  double m_x, m_y, m_radius;
  DrawingAPI *m_drawingAPI;
};

int main(void) {
  CircleShape circle1(1, 2, 3, new DrawingAPI1());
  CircleShape circle2(5, 7, 11, new DrawingAPI2());
  circle1.resizeByPercentage(2.5);
  circle2.resizeByPercentage(2.5);
  circle1.draw();
  circle2.draw();
  return 0;
}

#include <algorithm> // std::for_each
#include <iostream>  // std::cout
#include <memory>    // std::unique_ptr
#include <vector>
using namespace std;

class Graphic {
public:
  virtual void print() const = 0;
  virtual ~Graphic() {}
};

class Ellipse : public Graphic {
public:
  void print() const { cout << "Ellipse \n"; }
};

class CompositeGraphic : public Graphic {
public:
  void print() const {
    for (Graphic *a : graphicList_) {
      a->print();
    }
  }

  void add(Graphic *aGraphic) { graphicList_.push_back(aGraphic); }

private:
  vector<Graphic *> graphicList_;
};

int main() {
  // Initialize four ellipses
  const unique_ptr<Ellipse> ellipse1(new Ellipse());
  const unique_ptr<Ellipse> ellipse2(new Ellipse());
  const unique_ptr<Ellipse> ellipse3(new Ellipse());
  const unique_ptr<Ellipse> ellipse4(new Ellipse());

  // Initialize three composite graphics
  const unique_ptr<CompositeGraphic> graphic(new CompositeGraphic());
  const unique_ptr<CompositeGraphic> graphic1(new CompositeGraphic());
  const unique_ptr<CompositeGraphic> graphic2(new CompositeGraphic());

  // Composes the graphics
  graphic1->add(ellipse1.get());
  graphic1->add(ellipse2.get());
  graphic1->add(ellipse3.get());

  graphic2->add(ellipse4.get());

  graphic->add(graphic1.get());
  graphic->add(graphic2.get());

  // Prints the complete graphic (four times the string "Ellipse")
  graphic->print();
  return 0;
}

#include <iostream>
#include <memory>
#include <string>

class Interface {
public:
  virtual ~Interface() {}
  virtual void write(std::string &) = 0;
};

class Core : public Interface {
public:
  ~Core() { std::cout << "Core destructor called.\n"; }
  virtual void write(std::string &text) override{}; // Do nothing.
};

class Decorator : public Interface {
private:
  std::unique_ptr<Interface> interface;

public:
  Decorator(std::unique_ptr<Interface> c) { interface = std::move(c); }
  virtual void write(std::string &text) override { interface->write(text); }
};

class MessengerWithSalutation : public Decorator {
private:
  std::string salutation;

public:
  MessengerWithSalutation(std::unique_ptr<Interface> c, const std::string &str)
      : Decorator(std::move(c)), salutation(str) {}
  ~MessengerWithSalutation() { std::cout << "Messenger destructor called.\n"; }
  virtual void write(std::string &text) override {
    text = salutation + "\n\n" + text;
    Decorator::write(text);
  }
};

class MessengerWithValediction : public Decorator {
private:
  std::string valediction;

public:
  MessengerWithValediction(std::unique_ptr<Interface> c, const std::string &str)
      : Decorator(std::move(c)), valediction(str) {}
  ~MessengerWithValediction() {
    std::cout << "MessengerWithValediction destructor called.\n";
  }
  virtual void write(std::string &text) override {
    Decorator::write(text);
    text += "\n\n" + valediction;
  }
};

int main() {
  const std::string salutation = "Greetings,";
  const std::string valediction = "Sincerly, Andy";
  std::string message1 = "This message is not decorated.";
  std::string message2 = "This message is decorated with a salutation.";
  std::string message3 = "This message is decorated with a valediction.";
  std::string message4 =
      "This message is decorated with a salutation and a valediction.";

  std::unique_ptr<Interface> messenger1 = std::make_unique<Core>();
  std::unique_ptr<Interface> messenger2 =
      std::make_unique<MessengerWithSalutation>(std::make_unique<Core>(),
                                                salutation);
  std::unique_ptr<Interface> messenger3 =
      std::make_unique<MessengerWithValediction>(std::make_unique<Core>(),
                                                 valediction);
  std::unique_ptr<Interface> messenger4 =
      std::make_unique<MessengerWithValediction>(
          std::make_unique<MessengerWithSalutation>(std::make_unique<Core>(),
                                                    salutation),
          valediction);

  messenger1->write(message1);
  std::cout << message1 << '\n';
  std::cout << "\n------------------------------\n\n";

  messenger2->write(message2);
  std::cout << message2 << '\n';
  std::cout << "\n------------------------------\n\n";

  messenger3->write(message3);
  std::cout << message3 << '\n';
  std::cout << "\n------------------------------\n\n";

  messenger4->write(message4);
  std::cout << message4 << '\n';
  std::cout << "\n------------------------------\n\n";
}

/*
 * 外观模式是我认为最简单的设计模式之一……以下是一个简单的示例。
 *
 * 假设你的新家是个智能房屋，所有的家居都可被远程控制。这样向要打开灯只需要按下按钮
 * - 其他的设备比如电视、交流电、闹钟、音乐等一样。
 *
 * 当你离开家时，你需要按无数个按钮来确定所有的东西都已经关闭才能出门，如果你像我一
 * 样懒就会觉得太烦了，所以我使用定义了个“外观”在出门和回家时使用（“外观”函数代表那
 * 些按钮）所以当我回家和出门的时候，只需要按一个按钮，它就能帮我搞定所有这些问题。
 */

#include <iostream>
#include <string>

using namespace std;

class Alarm {
public:
  void alarmOn() { cout << "Alarm is on and house is secured" << endl; }
  void alarmOff() {
    cout << "Alarm is off and you can go into the house" << endl;
  }
};

class Ac {
public:
  void acOn() { cout << "Ac is on" << endl; }
  void acOff() { cout << "AC is off" << endl; }
};

class Tv {
public:
  void tvOn() { cout << "Tv is on" << endl; }
  void tvOff() { cout << "TV is off" << endl; }
};

class HouseFacade {
  Alarm alarm;
  Ac ac;
  Tv tv;

public:
  HouseFacade() {}

  void goToWork() {
    ac.acOff();
    tv.tvOff();
    alarm.alarmOn();
  }

  void comeHome() {
    alarm.alarmOff();
    ac.acOn();
    tv.tvOn();
  }
};

int main() {
  HouseFacade hf;

  // 现在不需要按那么一系列按钮来打开或关闭这些功能，多亏了外观模式我现在只需要
  // 两个函数就能搞定
  hf.goToWork();
  hf.comeHome();
}

#include <iostream>
#include <string>
#include <vector>

#define NUMBER_OF_SAME_TYPE_CHARS 3;

// 定义享元对象类
class FlyweightCharacter;

/*
 * FlyweightCharacterAbstractBuilder
 * 是一个包含很多对象共享属性的类。这样我们可以将这些属性独立出来，让原先的类
 * 轻量化。更多细节请看 main 函数中的注释。
 */
class FlyweightCharacterAbstractBuilder {
  FlyweightCharacterAbstractBuilder() {}
  ~FlyweightCharacterAbstractBuilder() {}

public:
  static std::vector<float> fontSizes;
  static std::vector<std::string> fontNames;  // 假设每个字符串 6 个字节

  static void setFontsAndNames();
  static FlyweightCharacter
  createFlyweightCharacter(unsigned short fontSizeIndex,
                           unsigned short fontNameIndex,
                           unsigned short positionInStream);
};

std::vector<float> FlyweightCharacterAbstractBuilder::fontSizes(3);
std::vector<std::string> FlyweightCharacterAbstractBuilder::fontNames(3);
void FlyweightCharacterAbstractBuilder::setFontsAndNames() {
  fontSizes[0] = 1.0;
  fontSizes[1] = 1.5;
  fontSizes[2] = 2.0;

  fontNames[0] = "first_font";
  fontNames[1] = "second_font";
  fontNames[2] = "third_font";
}

class FlyweightCharacter {
  unsigned short fontSizeIndex; // 序号而非真正的字体大小
  unsigned short fontNameIndex; // 序号而非真正的字体名字

  unsigned positionInStream;

public:
  FlyweightCharacter(unsigned short fontSizeIndex, unsigned short fontNameIndex,
                     unsigned short positionInStream)
      : fontSizeIndex(fontSizeIndex), fontNameIndex(fontNameIndex),
        positionInStream(positionInStream) {}
  void print() {
    std::cout << "Font Size: "
              << FlyweightCharacterAbstractBuilder::fontSizes[fontSizeIndex]
              << ", font Name: "
              << FlyweightCharacterAbstractBuilder::fontNames[fontNameIndex]
              << ", character stream position: " << positionInStream
              << std::endl;
  }
  ~FlyweightCharacter() {}
};

FlyweightCharacter FlyweightCharacterAbstractBuilder::createFlyweightCharacter(
    unsigned short fontSizeIndex, unsigned short fontNameIndex,
    unsigned short positionInStream) {
  FlyweightCharacter fc(fontSizeIndex, fontNameIndex, positionInStream);

  return fc;
}

int main(int argc, char **argv) {
  std::vector<FlyweightCharacter> chars;

  FlyweightCharacterAbstractBuilder::setFontsAndNames();
  unsigned short limit = NUMBER_OF_SAME_TYPE_CHARS;

  for (unsigned short i = 0; i < limit; i++) {
    chars.push_back(
        FlyweightCharacterAbstractBuilder::createFlyweightCharacter(0, 0, i));
    chars.push_back(FlyweightCharacterAbstractBuilder::createFlyweightCharacter(
        1, 1, i + 1 * limit));
    chars.push_back(FlyweightCharacterAbstractBuilder::createFlyweightCharacter(
        2, 2, i + 2 * limit));
  }
  /*
   * 每个字符类中链接至它的字体名称和大小，这样我们得到：
   *
   * 每个对象为 fontNameIndex 和 fontSizeIndex 各占 2 个字节，否则，float 需要 4
   * 字节，string 需要 6 个字节。这样，每个对象可以节省 6 + 4 - 2 - 2 = 6 比特。
   *
   * 这一设计模式将多个对象共享的属性移至另外的容器内。而原对象中不再保存这些数
   * 据，而是保存指向节省内存轻量化对象容器的链接。被另外保存的这些属性的容器，应
   * 该确实能够节省大量的内存，使得对象与之前相比更加轻便。这也就是这一设计模式名
   * 称的来源：flyweight（即非常轻）。
   */
  for (unsigned short i = 0; i < chars.size(); i++) {
    chars[i].print();
  }

  std::cin.get();
  return 0;
}

#include <iostream>
#include <memory>

class ICar {
public:
  virtual ~ICar() { std::cout << "ICar destructor!" << std::endl; }
  virtual void DriveCar() = 0;
};

class Car : public ICar {
public:
  void DriveCar() override { std::cout << "Car has been driven!" << std::endl; }
};

class ProxyCar : public ICar {
public:
  ProxyCar(int driver_age) : driver_age_(driver_age) {}
  void DriveCar() override {
    if (driver_age_ > 16) {
      real_car_->DriveCar();
    } else {
      std::cout << "Sorry, the driver is too young to drive." << std::endl;
    }
  }

private:
  std::unique_ptr<ICar> real_car_ = std::make_unique<Car>();
  int driver_age_;
};

int main() {
  std::unique_ptr<ICar> car = std::make_unique<ProxyCar>(16);
  car->DriveCar();

  car = std::make_unique<ProxyCar>(25);
  car->DriveCar();
  return 0;
}

#include <iostream>
using namespace std;

class Handler {
protected:
  Handler *next;

public:
  Handler() { next = NULL; }
  virtual ~Handler() {}
  virtual void request(int value) = 0;
  void setNextHandler(Handler *nextInLine) { next = nextInLine; }
};

class SpecialHandler : public Handler {
private:
  int myLimit;
  int myId;

public:
  SpecialHandler(int limit, int id) {
    myLimit = limit;
    myId = id;
  }

  ~SpecialHandler() {}

  void request(int value) {
    if (value < myLimit) {
      cout << "Handler " << myId << " handled the request with a limit of "
           << myLimit << endl;
    } else if (next != NULL) {
      next->request(value);
    } else {
      cout << "Sorry, I am the last handler (" << myId
           << ") and I can't handle the request." << endl;
    }
  }
};

int main() {
  Handler *h1 = new SpecialHandler(10, 1);
  Handler *h2 = new SpecialHandler(20, 2);
  Handler *h3 = new SpecialHandler(30, 3);

  h1->setNextHandler(h2);
  h2->setNextHandler(h3);

  h1->request(18);
  h1->request(40);

  delete h1;
  delete h2;
  delete h3;

  return 0;
}

#include <iostream>
using namespace std;

// 命令接口
class Command {
public:
  virtual void execute() = 0;
};

// 接收者类
class Light {
public:
  Light() {}
  void turnOn() { cout << "The light is on" << endl; }
  void turnOff() { cout << "The light is off" << endl; }
};

// 开灯命令
class FlipUpCommand : public Command {
public:
  FlipUpCommand(Light &light) : theLight(light) {}
  virtual void execute() { theLight.turnOn(); }

private:
  Light &theLight;
};

// 关灯命令
class FlipDownCommand : public Command {
public:
  FlipDownCommand(Light &light) : theLight(light) {}
  virtual void execute() { theLight.turnOff(); }

private:
  Light &theLight;
};

class Switch {
public:
  Switch(Command &flipUpCmd, Command &flipDownCmd)
      : flipUpCommand(flipUpCmd), flipDownCommand(flipDownCmd) {}
  void flipUp() { flipUpCommand.execute(); }
  void flipDown() { flipDownCommand.execute(); }

private:
  Command &flipUpCommand;
  Command &flipDownCommand;
};

int main() {
  Light lamp;
  FlipUpCommand switchUp(lamp);
  FlipDownCommand switchDown(lamp);

  Switch s(switchUp, switchDown);
  s.flipUp();
  s.flipDown();
}

#include <iostream>
#include <list>
#include <map>
#include <string>

namespace wikibooks_design_patterns {

// 这里的实现基于 Java 的示例
typedef std::string String;
struct Expression;
typedef std::map<String, Expression *> Map;
typedef std::list<Expression *> Stack;

struct Expression {
  virtual int interpret(Map variables) = 0;
  virtual ~Expression() {}
};

class Number : public Expression {
private:
  int number;

public:
  Number(int number) { this->number = number; }
  int interpret(Map variables) { return number; }
};

class Plus : public Expression {
  Expression *leftOperand;
  Expression *rightOperand;

public:
  Plus(Expression *left, Expression *right) {
    leftOperand = left;
    rightOperand = right;
  }
  ~Plus() {
    delete leftOperand;
    delete rightOperand;
  }

  int interpret(Map variables) {
    return leftOperand->interpret(variables) +
           rightOperand->interpret(variables);
  }
};

class Minus : public Expression {
  Expression *leftOperand;
  Expression *rightOperand;

public:
  Minus(Expression *left, Expression *right) {
    leftOperand = left;
    rightOperand = right;
  }
  ~Minus() {
    delete leftOperand;
    delete rightOperand;
  }

  int interpret(Map variables) {
    return leftOperand->interpret(variables) -
           rightOperand->interpret(variables);
  }
};

class Variable : public Expression {
  String name;

public:
  Variable(String name) { this->name = name; }
  int interpret(Map variables) {
    if (variables.end() == variables.find(name))
      return 0;
    return variables[name]->interpret(variables);
  }
};

// 解释器模式不进行解析器，为完整性而提供该解析器。
class Evaluator : public Expression {
  Expression *syntaxTree;

public:
  Evaluator(String expression) {
    Stack expressionStack;

    size_t last = 0;
    for (size_t next = 0; String::npos != last;
         last = (String::npos == next) ? next : (1 + next)) {
      next = expression.find(' ', last);
      String token(expression.substr(last, (String::npos == next)
                                               ? (expression.length() - last)
                                               : (next - last)));

      if (token == "+") {
        Expression *right = expressionStack.back();
        expressionStack.pop_back();
        Expression *left = expressionStack.back();
        expressionStack.pop_back();
        Expression *subExpression = new Plus(right, left);
        expressionStack.push_back(subExpression);
      } else if (token == "-") {
        // 从栈中移除首个和末个操作符很有必要
        Expression *right = expressionStack.back();
        expressionStack.pop_back();
        Expression *left = expressionStack.back();
        expressionStack.pop_back();
        Expression *subExpression = new Minus(left, right);
        expressionStack.push_back(subExpression);
      } else
        expressionStack.push_back(new Variable(token));
    }

    syntaxTree = expressionStack.back();
    expressionStack.pop_back();
  }

  ~Evaluator() { delete syntaxTree; }

  int interpret(Map context) { return syntaxTree->interpret(context); }
};

} // namespace wikibooks_design_patterns

int main() {
  using namespace wikibooks_design_patterns;

  Evaluator sentence("w x z - +");

  static const int sequences[][3] = {
      {5, 10, 42},
      {1, 3, 2},
      {7, 9, -5},
  };
  for (size_t i = 0; sizeof(sequences) / sizeof(sequences[0]) > i; ++i) {
    Map variables;
    variables["w"] = new Number(sequences[i][0]);
    variables["x"] = new Number(sequences[i][1]);
    variables["z"] = new Number(sequences[i][2]);
    int result = sentence.interpret(variables);
    for (Map::iterator it = variables.begin(); variables.end() != it; ++it)
      delete it->second;
    std::cout << "Interpreter result: " << result << std::endl;
  }
}

int main() {
  const int ARRAY_LEN = 42;
  int *myArray = new int[ARRAY_LEN];
  // 将迭代器指向数组中的第一个内存位置
  int *arrayItr = myArray;
  // i 将迭代器沿数组移动，使其为其在数组中的位置
  for (int i = 0; i < ARRAY_LEN; ++i) {
    // 将 arrayItr 赋值为 i 目前位置的值
    *arrayItr = i;
    // 通过递增指针，我们将其移动至数组的下一个位置。由于指针机制处理的迭
    // 代，这对与内存连续的容器是很容易的
    ++arrayItr;
  }
  // 别觉得烦，自己清理下
  delete[] myArray;
}

class IteratorCannotMoveToNext {}; // Error class
class MyIntLList {
public:
  // 类 Node 代表链表中的一个元素。这个节点包含指向下一个和上一个的
  // 节点，因此用户可以从一个位置移动到下一个，或回到上一个位置。注
  // 意遍历链表的复杂度为 O(N)，搜索的复杂度相同，由于链表并非排好
  // 序的。
  class Node {
  public:
    Node() : mNextNode(0), mPrevNode(0), mValue(0) {}
    Node *mNextNode;
    Node *mPrevNode;
    int mValue;
  };
  MyIntLList() : mSize(0) {}
  ~MyIntLList() {
    while (!Empty())
      pop_front();
  }
  int Size() const { return mSize; }
  // 将值添加到链表的末尾
  void push_back(int value) {
    Node *newNode = new Node;
    newNode->mValue = value;
    newNode->mPrevNode = mTail;
    mTail->mNextNode = newNode;
    mTail = newNode;
    ++mSize;
  }
  // 将值从链表的开头移除
  void pop_front() {
    if (Empty())
      return;
    Node *tmpnode = mHead;
    mHead = mHead->mNextNode;
    delete tmpnode;
    --mSize;
  }
  bool Empty() { return mSize == 0; }
  // 迭代器应定义于此，我们先完成链表的定义

private:
  Node *mHead;
  Node *mTail;
  int mSize;
};

/*
 *  迭代器类了解聊表的间隔，这样才可以移动到下一个元素。在以下实现中，我选
 *  择了最经典的遍历方式即重载自曾操作符。对双向链表更彻底的实现应该包括自
 *  减操作符，这样迭代器可以反向移动。
 */
class Iterator {
public:
  Iterator(Node *position) : mCurrNode(position) {}
  const Iterator &operator++() {
    if (mCurrNode == 0 || mCurrNode->mNextNode == 0)
      throw IteratorCannotMoveToNext();
    e mCurrNode = mCurrNode->mNextNode;
    return *this;
  }
  Iterator operator++(int) {
    Iterator tempItr = *this;
    ++(*this);
    return tempItr;
  }
  // 取值操作符返回当前的节点，再次对它取值即可获得 int 值。
  // TODO：检查重载取值操作符的语法。
  Node *operator*() { return mCurrNode; }
  // TODO：实现方向操作符，并清理以下的示例用法。
private:
  Node *mCurrNode;
};
// 以下的两个函数使得可以对链表类创建迭代器。
// 第一个迭代器应指向容器中的第一个元素。
Iterator Begin() { return Iterator(mHead); }
// 最后一个迭代器应为容器中最后一个元素的下一个。
Iterator End() { return Iterator(0); }