#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;
};