当前位置：首页 > news >正文

基于C++的《Head First设计模式》笔记——模式合作

news 2026/3/27 5:46:43

一.专栏简介

二.模式合作

三.与鸭子重聚

1.创建一个Quackable接口

2.鸭子实现Quackable

3.模拟器

四.加上鹅

五.鹅适配器

六.模拟器中加入鹅

七.叫声的统计

八.模拟器加入装饰者

九.工厂生产鸭子

十.模拟器使用工厂

十一.创建一群鸭子

十二.修改模拟器

十三.加入观察者模式代码

十四.总结

一.专栏简介

本专栏是我学习《head first》设计模式的笔记。这本书中是用Java语言为基础的，我将用C++语言重写一遍，并且详细讲述其中的设计模式，涉及是什么，为什么，怎么做，自己的心得等等。希望阅读者在读完我的这个专题后，也能在开发中灵活且正确的使用，或者在面对面试官时，能够自信地说自己熟悉常用设计模式。

本章将开始模式合作的学习，这是复合模式的前传。

二.模式合作

模式通常被一起使用，并结合在同一个设计解决方案中。

复合模式在一个解决方案中结合两个或多个模式，以解决一般的或重复发生的问题。

三.与鸭子重聚

正如你已经知道的，我们会再次和鸭子合作，这一次，鸭子将在同一个解决方案中，展示模式如何共存甚至合作。

我们将从头重建我们的鸭子模拟器，并通过使用一堆模式，给它一些有趣的能力，OK，我们开始......

1.创建一个Quackable接口

struct Quackable { virtual void quack() = 0; };

2.鸭子实现Quackable

class MallardDuck : public Quackable { public: void quack() override { cout << "Quack" << endl; } }; class RedheadDuck : public Quackable { public: void quack() override { cout << "Quack" << endl; } }; // 鸭鸣器 class DuckCall : public Quackable { public: void quack() override { cout << "Kwak" << endl; } }; // 橡皮鸭 class RubberDuck : public Quackable { public: void quack() override { cout << "Squeak" << endl; } };

3.模拟器

我们制造一个模拟器，这个模拟器会创建一些鸭子，并保证它们会呱呱叫......

static void simulate(Quackable* duck) { duck->quack(); } static void simulate() { Quackable* mallardDuck = new MallardDuck(); Quackable* redheadDuck = new RedheadDuck(); Quackable* duckCall = new DuckCall(); Quackable* rubberDuck = new RubberDuck(); cout << "Duck Simulator\n"; simulate(mallardDuck); simulate(redheadDuck); simulate(duckCall); simulate(rubberDuck); } int main() { simulate(); return 0; }

运行结果：

四.加上鹅

class Goose { public: void honk() { cout << "Honk" << endl; } };

假设我们想要在使用鸭的地方使用鹅，毕竟鹅也会叫、会飞、会游。为什么我们不能在模拟器中使用鹅？适配器模式可以让我们轻易地将鸭和鹅掺和在一起。

五.鹅适配器

class GooseAdapter : public Quackable { public: GooseAdapter(Goose* g): goose(g) {} void quack() override { goose->honk(); } private: Goose* goose; };

六.模拟器中加入鹅

static void simulate(Quackable* duck) { duck->quack(); } static void simulate() { Quackable* mallardDuck = new MallardDuck(); Quackable* redheadDuck = new RedheadDuck(); Quackable* duckCall = new DuckCall(); Quackable* rubberDuck = new RubberDuck(); Quackable* gooseDuck = new GooseAdapter(new Goose()); cout << "Duck Simulator\n"; simulate(mallardDuck); simulate(redheadDuck); simulate(duckCall); simulate(rubberDuck); simulate(gooseDuck); } int main() { simulate(); return 0; }

运行结果：

呱呱叫学家为可呱呱叫行为的所有方面着迷，方法学家经常研究的其中一件事：在一群鸭子中，总共发出了多少呱呱叫声？

在不必修改鸭子类的情况下，我们如何添加统计嘎嘎叫次数的能力，当然是装饰模式为鸭子类加上统计嘎嘎叫的责任和能力。

七.叫声的统计

class QuackCounter : public Quackable { public: QuackCounter(Quackable* d): duck(d) {} void quack() { duck->quack(); ++numberOfQuacks; } static int getQuacks() { return numberOfQuacks; } private: Quackable* duck; static int numberOfQuacks; };

八.模拟器加入装饰者

#include "compound.h" static void simulate(Quackable* duck) { duck->quack(); } static void simulate() { Quackable* mallardDuck = new QuackCounter(new MallardDuck()); Quackable* redheadDuck = new QuackCounter(new RedheadDuck()); Quackable* duckCall = new QuackCounter(new DuckCall()); Quackable* rubberDuck = new QuackCounter(new RubberDuck()); Quackable* gooseDuck = new GooseAdapter(new Goose()); cout << "Duck Simulator\n"; simulate(mallardDuck); simulate(redheadDuck); simulate(duckCall); simulate(rubberDuck); simulate(gooseDuck); cout << "The ducks quacked " << QuackCounter::getQuacks() << " times" << endl; } int main() { simulate(); return 0; }

运行结果：

但是这有问题：我们不得不确认它们被包装，否则就得不到被装饰的行为。

我们需要封装鸭子的创建和装饰，这就是工厂模式。

九.工厂生产鸭子

我们需要一些质量控制，以确保鸭子得到包装。我们建造一个完整的工厂，专门生产这些鸭子。该工厂应该生产产品家族，包含不同类型的鸭子，因此我们要用抽象工厂模式。

class AbstractDuckFactory { public: virtual Quackable* createMallardDuck() = 0; virtual Quackable* createRedheadDuck() = 0; virtual Quackable* createDuckCall() = 0; virtual Quackable* createRubberDuck() = 0; }; class DuckFactory : public AbstractDuckFactory { public: Quackable* createMallardDuck() override { return new MallardDuck(); } Quackable* createRedheadDuck() override { return new RedheadDuck(); } Quackable* createDuckCall() override { return new DuckCall(); } Quackable* createRubberDuck() override { return new RubberDuck(); } }; class CountingDuckFactory : public AbstractDuckFactory { public: Quackable* createMallardDuck() override { return new QuackCounter(new MallardDuck()); } Quackable* createRedheadDuck() override { return new QuackCounter(new RedheadDuck()); } Quackable* createDuckCall() override { return new QuackCounter(new DuckCall()); } Quackable* createRubberDuck() override { return new QuackCounter(new RubberDuck()); } };

其中一个创建不带装饰者鸭子的工厂和一个带装饰者鸭子的工厂。

十.模拟器使用工厂

static void simulate(Quackable* duck) { duck->quack(); } static void simulate(AbstractDuckFactory* duckFactory) { Quackable* mallardDuck = duckFactory->createMallardDuck(); Quackable* redheadDuck = duckFactory->createRedheadDuck(); Quackable* duckCall = duckFactory->createDuckCall(); Quackable* rubberDuck = duckFactory->createRubberDuck(); Quackable* gooseDuck = new GooseAdapter(new Goose()); cout << "Duck Simulator\n"; simulate(mallardDuck); simulate(redheadDuck); simulate(duckCall); simulate(rubberDuck); simulate(gooseDuck); cout << "The ducks quacked " << QuackCounter::getQuacks() << " times" << endl; } int main() { AbstractDuckFactory* duckFactory = new CountingDuckFactory(); simulate(duckFactory); return 0; }

运行结果：

和上次一样，但是这次我们确定所有的鸭子都被装饰过，因为我们使用了CountingDuckFactory。

但现在的问题是要分别管理这些不同的鸭子变得有些困难了，我们想把这些鸭子作为一个整体来管理，甚至让我们能够管理几个想持续追踪的鸭子家族。

我们需要一种方法来谈论鸭子集合，甚至子集合。这显然是组合模式。

十一.创建一群鸭子

组合模式允许我们将一个对象集合像单个对象一样对待，对一群Quackable来说，组合模式最合适不过了！

让我们逐步看如何运作：

class Flock : public Quackable { public: void add(Quackable* quackable) { quackers.push_back(quackable); } void quack() { for (const auto& e : quackers) { e->quack(); } } private: vector<Quackable*> quackers; };

这里我们还用到了迭代器模式，也就是quack里的那个语法糖循环。

十二.修改模拟器

#include "compound.h" static void simulate(Quackable* duck) { duck->quack(); } static void simulate(AbstractDuckFactory* duckFactory) { Quackable* redheadDuck = duckFactory->createRedheadDuck(); Quackable* duckCall = duckFactory->createDuckCall(); Quackable* rubberDuck = duckFactory->createRubberDuck(); Quackable* gooseDuck = duckFactory->createGooseDuck(); Flock* flockOfDucks = new Flock(); flockOfDucks->add(redheadDuck); flockOfDucks->add(duckCall); flockOfDucks->add(rubberDuck); flockOfDucks->add(gooseDuck); Flock* flockOfMallard = new Flock(); Quackable* mallard1 = duckFactory->createMallardDuck(); Quackable* mallard2 = duckFactory->createMallardDuck(); Quackable* mallard3 = duckFactory->createMallardDuck(); Quackable* mallard4 = duckFactory->createMallardDuck(); flockOfMallard->add(mallard1); flockOfMallard->add(mallard2); flockOfMallard->add(mallard3); flockOfMallard->add(mallard4); flockOfDucks->add(flockOfMallard); cout << "Duck Simulator : Whole Flock Simulation\n"; simulate(flockOfDucks); cout << "\nDuck Simulator : Mallard Flock Simulation\n"; simulate(flockOfMallard); cout << "The ducks quacked " << QuackCounter::getQuacks() << " times" << endl; } int main() { AbstractDuckFactory* duckFactory = new CountingDuckFactory(); simulate(duckFactory); return 0; }

运行结果：

组合运行得很流畅！但现在我们有一个相反的要求：我们还需要跟踪个别的鸭子，支持我们跟踪个别鸭子的实时嘎嘎叫。观察者模式上场。

十三.加入观察者模式代码

compound.h:

#pragma once #include <iostream> #include <vector> using namespace std; class Observer; struct QuackObservable { virtual void registerObservable(Observer* observer) = 0; virtual void notifyObservers() = 0; }; class Observer { public: virtual void update(QuackObservable* duck) = 0; }; class QuackoLogist : public Observer { public: void update(QuackObservable* duck) override { cout << "QuackoLogist：" << typeid(*duck).name() << " just quacked." << endl; } }; struct Quackable : public QuackObservable { virtual void quack() = 0; }; class Observable : public QuackObservable { public: Observable(QuackObservable* d): duck(d) {} void registerObservable(Observer* observer) override { observers.push_back(observer); } void notifyObservers() override { for (const auto& e : observers) { e->update(duck); } } private: vector<Observer*> observers; QuackObservable* duck; }; class MallardDuck : public Quackable { public: MallardDuck() { observable = new Observable(this); } void quack() override { cout << "Quack" << endl; notifyObservers(); } void registerObservable(Observer* observer) override { observable->registerObservable(observer); } void notifyObservers() override { observable->notifyObservers(); } private: Observable* observable; }; class RedheadDuck : public Quackable { public: RedheadDuck() { observable = new Observable(this); } void quack() override { cout << "Quack" << endl; notifyObservers(); } void registerObservable(Observer* observer) override { observable->registerObservable(observer); } void notifyObservers() override { observable->notifyObservers(); } private: Observable* observable; }; // 鸭鸣器 class DuckCall : public Quackable { public: DuckCall() { observable = new Observable(this); } void quack() override { cout << "Kwak" << endl; notifyObservers(); } void registerObservable(Observer* observer) override { observable->registerObservable(observer); } void notifyObservers() override { observable->notifyObservers(); } private: Observable* observable; }; // 橡皮鸭 class RubberDuck : public Quackable { public: RubberDuck() { observable = new Observable(this); } void quack() override { cout << "Squeak" << endl; notifyObservers(); } void registerObservable(Observer* observer) override { observable->registerObservable(observer); } void notifyObservers() override { observable->notifyObservers(); } private: Observable* observable; }; class Goose { public: void honk() { cout << "Honk" << endl; } }; class GooseAdapter : public Quackable { public: GooseAdapter(Goose* g): goose(g) { observable = new Observable(this); } void quack() override { goose->honk(); notifyObservers(); } void registerObservable(Observer* observer) override { observable->registerObservable(observer); } void notifyObservers() override { observable->notifyObservers(); } private: Goose* goose; Observable* observable; }; class QuackCounter : public Quackable { public: QuackCounter(Quackable* d): duck(d) { observable = new Observable(this); } void quack() { duck->quack(); ++numberOfQuacks; notifyObservers(); } void registerObservable(Observer* observer) override { observable->registerObservable(observer); } void notifyObservers() override { observable->notifyObservers(); } static int getQuacks() { return numberOfQuacks; } private: Quackable* duck; static int numberOfQuacks; Observable* observable; }; int QuackCounter::numberOfQuacks; class AbstractDuckFactory { public: virtual Quackable* createMallardDuck() = 0; virtual Quackable* createRedheadDuck() = 0; virtual Quackable* createDuckCall() = 0; virtual Quackable* createRubberDuck() = 0; virtual Quackable* createGooseDuck() = 0; }; class DuckFactory : public AbstractDuckFactory { public: Quackable* createMallardDuck() override { return new MallardDuck(); } Quackable* createRedheadDuck() override { return new RedheadDuck(); } Quackable* createDuckCall() override { return new DuckCall(); } Quackable* createRubberDuck() override { return new RubberDuck(); } Quackable* createGooseDuck() override { return new GooseAdapter(new Goose()); } }; class CountingDuckFactory : public AbstractDuckFactory { public: Quackable* createMallardDuck() override { return new QuackCounter(new MallardDuck()); } Quackable* createRedheadDuck() override { return new QuackCounter(new RedheadDuck()); } Quackable* createDuckCall() override { return new QuackCounter(new DuckCall()); } Quackable* createRubberDuck() override { return new QuackCounter(new RubberDuck()); } Quackable* createGooseDuck() override { return new GooseAdapter(new Goose()); } }; class Flock : public Quackable { public: void add(Quackable* quackable) { quackers.push_back(quackable); } void quack() { for (const auto& e : quackers) { e->quack(); } } void registerObservable(Observer* observer) { for (const auto& e : quackers) { e->registerObservable(observer); } } void notifyObservers() { } private: vector<Quackable*> quackers; };

main.cpp:

#include "compound.h" static void simulate(Quackable* duck) { duck->quack(); } static void simulate(AbstractDuckFactory* duckFactory) { Quackable* redheadDuck = duckFactory->createRedheadDuck(); Quackable* duckCall = duckFactory->createDuckCall(); Quackable* rubberDuck = duckFactory->createRubberDuck(); Quackable* gooseDuck = duckFactory->createGooseDuck(); Flock* flockOfDucks = new Flock(); flockOfDucks->add(redheadDuck); flockOfDucks->add(duckCall); flockOfDucks->add(rubberDuck); flockOfDucks->add(gooseDuck); Flock* flockOfMallard = new Flock(); Quackable* mallard1 = duckFactory->createMallardDuck(); Quackable* mallard2 = duckFactory->createMallardDuck(); Quackable* mallard3 = duckFactory->createMallardDuck(); Quackable* mallard4 = duckFactory->createMallardDuck(); flockOfMallard->add(mallard1); flockOfMallard->add(mallard2); flockOfMallard->add(mallard3); flockOfMallard->add(mallard4); flockOfDucks->add(flockOfMallard); Observer* quackoLogist = new QuackoLogist(); flockOfDucks->registerObservable(quackoLogist); cout << "Duck Simulator : Whole Flock Simulation\n"; simulate(flockOfDucks); //cout << "\nDuck Simulator : Mallard Flock Simulation\n"; //simulate(flockOfMallard); cout << "The ducks quacked " << QuackCounter::getQuacks() << " times" << endl; } int main() { AbstractDuckFactory* duckFactory = new CountingDuckFactory(); simulate(duckFactory); return 0; }

运行结果：

大功告成，我们的观察者模式也运行正确。

这是一个大场面的终局。六个模式一起来创建这个令人惊叹的鸭子模拟器。