设计模式笔记

1builder.add_child("li", "hello").add_child("li", "world");
2builder->add_child("li", "hello")->add_child("li", "world");

 1#include <cstdio>
 2
 3class Html
 4{
 5public:
 6    void str()
 7    {
 8        printf("str");
 9    }
10
11protected:
12    Html() = default;
13    friend class HtmlBuilder;
14};
15
16class HtmlBuilder
17{
18    Html html;
19
20public:
21    operator Html() const
22    {
23        return html;
24    }
25};
26
27int main()
28{
29    HtmlBuilder builder;
30    Html root = builder;
31    root.str();
32}

 1import groovy.transform.builder.Builder
 2
 3@Builder(builderMethodName = 'initiator', buildMethodName = 'create')
 4class Message {
 5    String from, to, subject, body
 6}
 7
 8def message = Message.initiator()
 9        .from('mrhaki@mrhaki.com')
10        .body('Groovy rocks!')
11        .create()
12
13assert message.body == 'Groovy rocks!'
14assert message.from == 'mrhaki@mrhaki.com'

1var body: some View {
2    VStack {
3        Text("Hello, World!")
4            .font(.largeTitle)
5        Button("Tap me!") {
6            print("Button was tapped")
7        }
8    }
9}

 1// 接口
 2class Target {
 3public:
 4    virtual void request() = 0;
 5};
 6
 7// 与接口不兼容的类
 8class Adaptee {
 9public:
10    void specificRequest() {
11        std::cout << "Adaptee::specificRequest()" << std::endl;
12    }
13};
14
15// 通过多继承的方式实现
16class Adapter : public Adaptee, public Target {
17public:
18    void request() override {
19        specificRequest();
20    }
21};
22
23int main() {
24    Target* target = new Adapter();
25    target->request();
26
27    delete target;
28    return 0;
29}

 1class Target {
 2public:
 3    virtual void request() = 0;
 4};
 5
 6class Adaptee {
 7public:
 8    void specificRequest() {
 9        std::cout << "Adaptee::specificRequest()" << std::endl;
10    }
11};
12
13class Adapter : public Target {
14public:
15    Adapter(Adaptee* adaptee) : m_adaptee(adaptee) {}
16
17    void request() override {
18        m_adaptee->specificRequest();
19    }
20
21private:
22    Adaptee* m_adaptee;
23};
24
25int main() {
26    Adaptee* adaptee = new Adaptee();
27    Target* target = new Adapter(adaptee);
28    target->request();
29
30    delete target;
31    delete adaptee;
32    return 0;
33}

 1class Target {
 2public:
 3    virtual void request() = 0;
 4};
 5
 6class Adaptee {
 7public:
 8    void method1() {
 9        std::cout << "Adaptee::method1()" << std::endl;
10    }
11
12    void method2() {
13        std::cout << "Adaptee::method2()" << std::endl;
14    }
15
16    void method3() {
17        std::cout << "Adaptee::method3()" << std::endl;
18    }
19};
20
21// 使用Adapter类只实现method1接口
22class Adapter : public Target, public Adaptee {
23public:
24    void request() override {
25        method1();
26    }
27};
28
29int main() {
30    Target* target = new Adapter();
31    target->request();
32
33    delete target;
34    return 0;
35}

 1// 定义 Shape 类，作为抽象化角色。它持有一个 Renderer 类型的指针，并在 draw 函数中调用 Renderer 的 renderCircle 函数。
 2class Renderer {
 3public:
 4    virtual void renderCircle(float x, float y, float radius) = 0;
 5};
 6
 7class Shape {
 8protected:
 9    Renderer* renderer;
10
11public:
12    Shape(Renderer* renderer) : renderer(renderer) {}
13
14    virtual void draw() = 0;
15    virtual void resize(float factor) = 0;
16};
17
18// 定义 Circle 类，作为改善后的抽象化角色。它继承自 Shape 类，增加了一个 radius 成员变量，并在 draw 函数中调用 Renderer 的 renderCircle 函数。
19class Circle : public Shape {
20private:
21    float x, y, radius;
22
23public:
24    Circle(Renderer* renderer, float x, float y, float radius)
25        : Shape(renderer), x(x), y(y), radius(radius) {}
26
27    void draw() override {
28        renderer->renderCircle(x, y, radius);
29    }
30
31    void resize(float factor) override {
32        radius *= factor;
33    }
34};
35
36// 定义 Renderer 类及其两个具体实现类 RedCircle 和 GreenCircle，作为实现者角色。它们都实现了 renderCircle 函数，用于渲染圆形。
37class Renderer {
38public:
39    virtual void renderCircle(float x, float y, float radius) = 0;
40};
41
42class RedCircle : public Renderer {
43public:
44    void renderCircle(float x, float y, float radius) override {
45        cout << "Drawing red circle at (" << x << ", " << y << ") with radius " << radius << endl;
46    }
47};
48
49class GreenCircle : public Renderer {
50public:
51    void renderCircle(float x, float y, float radius) override {
52        cout << "Drawing green circle at (" << x << ", " << y << ") with radius " << radius << endl;
53    }
54};
55
56// 绘制
57int main() {
58    Renderer* renderer = new RedCircle();
59    Shape* circle = new Circle(renderer, 5, 5, 10);
60    circle->draw();
61
62    circle->resize(2);
63    circle->draw();
64
65    delete circle;
66    delete renderer;
67
68    renderer = new GreenCircle();
69    circle = new Circle(renderer, 10, 10, 20);
70    circle->draw();
71
72    delete circle;
73    delete renderer;
74
75    return 0;
76}

 1template <typename Self>
 2struct SomeNeurons
 3{
 4    template <typename T> void connect_to(T& other)
 5    {
 6        for (Neuron& from : *static_cast<Self*>(this))
 7        {
 8            for (Neuron& to : other)
 9            {
10                from.out.push_back(&to);
11                to.in.push_back(&from);
12            }
13        }
14    }
15};
16
17struct Neuron
18{
19    vector<Neuron*> in, out;
20    unsigned int id;
21
22    Neuron()
23    {
24        static int id = 1;
25        this->id = id++;
26    }
27}
28
29struct SingleNeuron : Neuron,
30                      SomeNeurons<SingleNeuron>
31{
32
33}
34
35
36struct NeuronLayer : Neuron,
37                     vector<Neuron>,
38                     SomeNeurons<NeuronLayer>
39{
40
41}

 1struct ColoredShape : Shape
 2{
 3    Shape& shape;
 4    string color;
 5    ColoredShape(Shape& shape, const string& color) :
 6            shape{shape}, color{color} {}
 7};
 8
 9
10struct TransparentShape : Shape
11{
12    Shape& shape;
13    uint8_t transparency;
14    TransparentShape(Shape& shape, uint8_t transparency) :
15            shape{shape}, transparency{transparency} {}
16};
17
18
19// 多个功能的, 使用多态实现功能的叠加
20TransparentShape s{ColoredShape{Circle{1.2}, "red"}, 100};

 1template <typename... Mixins>
 2class Point : public Mixins... {
 3public:
 4    double x, y;
 5    Point() : Mixins()..., x(0.0), y(0.0) {}
 6    Point(double x, double y) : Mixins()..., x(x), y(y) {}
 7};
 8class Label {
 9public:
10    std::string label;
11    Label() : label("") {}
12};
13class Color {
14public:
15    unsigned char red = 0, green = 0, blue = 0;
16};
17using MyPoint = Point<Label, Color>;

 1import logging
 2import time
 3
 4def logger(func):
 5    logging.basicConfig(filename='example.log', level=logging.INFO)
 6
 7    def wrapper(*args, **kwargs):
 8        start_time = time.time()
 9        result = func(*args, **kwargs)
10        end_time = time.time()
11        run_time = end_time - start_time
12        logging.info("Function {}() ran in {} seconds with result: {}".format(
13            func.__name__, run_time, result))
14        return result
15
16    return wrapper
17
18@logger
19def add(x, y):
20    return x + y
21
22print(add(2, 3))  # 输出 5，同时将日志写入 example.log 文件中

 1#include <iostream>
 2
 3// 子系统类A
 4class SubsystemA {
 5public:
 6    void operationA() {
 7        std::cout << "Subsystem A operation" << std::endl;
 8    }
 9};
10
11// 子系统类B
12class SubsystemB {
13public:
14    void operationB() {
15        std::cout << "Subsystem B operation" << std::endl;
16    }
17};
18
19// 外观类
20class Facade {
21private:
22    SubsystemA* subsystemA;
23    SubsystemB* subsystemB;
24public:
25    Facade() {
26        subsystemA = new SubsystemA();
27        subsystemB = new SubsystemB();
28    }
29    ~Facade() {
30        delete subsystemA;
31        delete subsystemB;
32    }
33    // 对外提供的简单接口
34    void operation() {
35        subsystemA->operationA();
36        subsystemB->operationB();
37    }
38};
39
40// 客户端代码
41int main() {
42    Facade* facade = new Facade();
43    facade->operation();
44    delete facade;
45    return 0;
46}

 1class CreatureModifier
 2{
 3    CreatureModifier* next{nullptr};
 4protected:
 5    Creature& creature; // alternative: pointer or shared_ptr
 6public:
 7    explicit CreatureModifier(Creature& creature):
 8        creature(creature) {}
 9
10    void add(CreatureModifier* cm)
11    {
12        if (next) next->add(cm);
13        else next = cm;
14    }
15
16    virtual void handle()
17    {
18        if (next) next->handle(); // critical!
19    }
20};

 1class DoubleAttackModifier : public CreatureModifier
 2{
 3public:
 4    explicit DoubleAttackModifier(Creature &creature)
 5            : CreatureModifier(creature) {}
 6
 7    void handle() override
 8    {
 9        creature.attack *= 2;
10        CreatureModifier::handle();
11    }
12};

 1struct Game // mediator
 2{
 3    signal<void(Query & )> queries;
 4};
 5
 6struct Query
 7{
 8    string creature_name;
 9    enum Argument
10    {
11        attack, defense
12    } argument;
13    int result;
14};
15
16class Creature
17{
18    Game &game;
19    int attack, defense;
20public:
21    string name
22
23    Creature(Game &game, ...) : game{game}, ...
24    { ... }
25// other members here
26};
27
28int Creature::get_attack() const
29{
30    Query q{name, Query::Argument::attack, attack};
31    game.queries(q);
32    return q.result;
33}
34
35class CreatureModifier
36{
37    Game &game;
38    Creature &creature;
39public:
40    CreatureModifier(Game &game, Creature &creature)
41            : game(game), creature(creature)
42    {}
43};
44
45class DoubleAttackModifier : public CreatureModifier
46{
47    connection conn;
48public:
49    DoubleAttackModifier(Game &game, Creature &creature)
50            : CreatureModifier(game, creature)
51    {
52        conn = game.queries.connect([&](Query &q) {
53            if (q.creature_name == creature.name &&
54                q.argument == Query::Argument::attack)
55                q.result *= 2;
56        });
57    }
58
59    ~DoubleAttackModifier()
60    { conn.disconnect(); }
61};
62Game game;
63Creature goblin{game, "Strong Goblin", 2, 2};
64cout << goblin << endl;
65// name: Strong Goblin attack: 2 defense: 2
66DoubleAttackModifier dam{game, goblin};
67cout << goblin << endl;
68// name: Strong Goblin attack: 4 defense: 2
69cout << goblin << endl;
70// name: Strong Goblin attack: 2 defense: 2

 1#include <iostream>
 2using namespace std;
 3
 4// 命令接口
 5class Command {
 6public:
 7    virtual void execute() = 0;
 8};
 9
10// 具体命令
11class ConcreteCommand : public Command {
12public:
13    ConcreteCommand() {}
14    ~ConcreteCommand() {}
15
16    void execute() {
17        cout << "执行命令..." << endl;
18    }
19};
20
21// 调用对象
22class Invoker {
23public:
24    Invoker(Command *cmd) {
25        m_cmd = cmd;
26    }
27
28    ~Invoker() {
29        delete m_cmd;
30        m_cmd = nullptr;
31    }
32
33    void invoke() {
34        m_cmd->execute();
35    }
36
37private:
38    Command *m_cmd;
39};
40
41// 客户端
42int main() {
43    Command *cmd = new ConcreteCommand();
44    Invoker *invoker = new Invoker(cmd);
45    invoker->invoke();
46
47    delete invoker;
48    return 0;
49}

 1#include <iostream>
 2#include <vector>
 3using namespace std;
 4
 5// 命令接口
 6class Command {
 7public:
 8    virtual void execute() = 0;
 9    virtual void undo() = 0;
10};
11
12// 具体命令类
13class ConcreteCommand : public Command {
14public:
15    ConcreteCommand(int& value, int delta) : m_value(value), m_delta(delta) {}
16    virtual void execute() override {
17        m_prevValue = m_value;
18        m_value += m_delta;
19    }
20    virtual void undo() override {
21        m_value = m_prevValue;
22    }
23private:
24    int& m_value;
25    int m_delta;
26    int m_prevValue;
27};
28
29// 命令管理类
30class CommandManager {
31public:
32    void execute(Command* cmd) {
33        m_commands.push_back(cmd);
34        cmd->execute();
35    }
36    void undo() {
37        if (!m_commands.empty()) {
38            Command* cmd = m_commands.back();
39            m_commands.pop_back();
40            cmd->undo();
41            delete cmd;
42        }
43    }
44private:
45    vector<Command*> m_commands;
46};
47
48int main() {
49    int value = 0;
50    CommandManager manager;
51    manager.execute(new ConcreteCommand(value, 1)); // value = 1
52    manager.execute(new ConcreteCommand(value, 2)); // value = 3
53    manager.execute(new ConcreteCommand(value, 3)); // value = 6
54    manager.undo(); // value = 3
55    manager.undo(); // value = 1
56    manager.undo(); // value = 0
57    manager.undo(); // do nothing
58    return 0;
59}

1struct CompositeBankAccountCommand : vector<BankAccountCommand>, Command

 1class Creature
 2{
 3    int strength, agility;
 4public:
 5    Creature(int strength, int agility)
 6            : strength{strength}, agility{agility}
 7    {}
 8
 9    void process_command(const CreatureCommand &cc);
10    int process_query(const CreatureQuery &q) const;
11};

  1#include <string>
  2#include <utility>
  3#include <iostream>
  4#include <ostream>
  5#include <sstream>
  6#include <vector>
  7
  8using namespace std;
  9
 10struct Token
 11{
 12    enum Type
 13    {
 14        t_integer,
 15        t_plus,
 16        t_minus,
 17        t_lparen,
 18        t_rparen,
 19    };
 20
 21    Type type;
 22    string text;
 23
 24    explicit Token(Type type, string text) :
 25            type(type), text(std::move(text))
 26    {}
 27
 28    friend ostream &operator<<(ostream &os, const Token &obj)
 29    {
 30        return os << "`" << obj.text << "`";
 31    }
 32};
 33
 34vector<Token> lex(const string &input)
 35{
 36    vector<Token> result;
 37    ostringstream buffer;
 38    auto add_integer = [&] {
 39        if (buffer.precision()) {
 40            result.emplace_back(Token{Token::t_integer, buffer.str()});
 41            buffer.str("");
 42        }
 43    };
 44    for (char c : input) {
 45        switch (c) {
 46            case '+':
 47                add_integer();
 48                result.emplace_back(Token{Token::t_plus, "+"});
 49                break;
 50            case '-':
 51                add_integer();
 52                result.emplace_back(Token{Token::t_minus, "-"});
 53                break;
 54            case '(':
 55                add_integer();
 56                result.emplace_back(Token{Token::t_lparen, "("});
 57                break;
 58            case ')':
 59                add_integer();
 60                result.emplace_back(Token{Token::t_rparen, ")"});
 61                break;
 62            case '0':
 63            case '1':
 64            case '2':
 65            case '3':
 66            case '4':
 67            case '5':
 68            case '6':
 69            case '7':
 70            case '8':
 71            case '9':
 72                buffer << c;
 73                break;
 74            default:
 75                break;
 76        }
 77    }
 78    add_integer();
 79    return result;
 80}
 81
 82struct Element
 83{
 84    virtual int eval() const = 0;
 85};
 86
 87struct Integer : Element
 88{
 89    int value;
 90
 91    explicit Integer(const int value) :
 92            value(value)
 93    {}
 94
 95    int eval() const override
 96    { return value; }
 97};
 98
 99struct BinaryOperation : Element
100{
101    enum Type
102    {
103        t_addition,
104        t_subtraction,
105    };
106
107    Type type;
108    shared_ptr<Element> lhs, rhs;
109
110    int eval() const override
111    {
112        if (type == t_addition) {
113            return lhs->eval() + rhs->eval();
114        } else {
115            return lhs->eval() - rhs->eval();
116        }
117    }
118};
119
120shared_ptr<Element> parse(const vector<Token> &tokens)
121{
122    auto result = make_unique<BinaryOperation>();
123    bool have_lhs = false;
124    for (int i = 0; i < tokens.size(); ++i) {
125        auto token = tokens[i];
126        switch (token.type) {
127            case Token::t_integer: {
128                int value = stoi(token.text);
129                auto integer = make_shared<Integer>(value);
130                if (!have_lhs) {
131                    result->lhs = integer;
132                    have_lhs = true;
133                } else {
134                    result->rhs = integer;
135                }
136            }
137            case Token::t_plus:
138                result->type = BinaryOperation::t_addition;
139                break;
140            case Token::t_minus:
141                result->type = BinaryOperation::t_subtraction;
142                break;
143            case Token::t_lparen: {
144                int j = i;
145                for (; j < tokens.size(); ++j) {
146                    if (tokens[j].type == Token::t_rparen) {
147                        break;
148                    }
149                }
150                vector<Token> subexpression(&tokens[i + 1], &tokens[j]);
151                auto element = parse(subexpression);
152                if (!have_lhs) {
153                    result->lhs = element;
154                    have_lhs = true;
155                } else {
156                    result->rhs = element;
157                    i = j;
158                }
159            }
160            case Token::t_rparen:
161                break;
162        }
163    }
164    return result;
165}
166
167template<typename T>
168ostream &operator<<(ostream &os, vector<T> vec)
169{
170    for (auto &e : vec) {
171        os << e;
172    }
173    return os;
174}
175
176int main()
177{
178    auto tokens = lex("4+(13+2)");
179    cout << tokens << endl;
180    auto parsed = parse(tokens);
181    cout << parsed->eval() << endl;
182}

 1template<typename T, int N>
 2class rray
 3{
 4public:
 5    using iterator = T *;
 6
 7    iterator begin()
 8    {
 9        return &data[0];
10    }
11
12    iterator end()
13    {
14        return &data[N];
15    }
16
17    T &operator[](int index)
18    {
19        return data[index];
20    }
21
22private:
23    T data[N];
24};
25
26int main(int argc, char *argv[])
27{
28    Aray<int, 10> a{};
29    for (auto &it : a) {
30        it = 1;
31    }
32}

 1#include <iostream>
 2#include <string>
 3#include <vector>
 4
 5using namespace std;
 6
 7class Colleague;
 8
 9// 抽象中介者
10class Mediator {
11public:
12    virtual void send(string message, Colleague* colleague) = 0;
13};
14
15// 具体中介者
16class ConcreteMediator : public Mediator {
17public:
18    void setColleague(vector<Colleague*> colleagues) {
19        this->colleagues = colleagues;
20    }
21
22    void send(string message, Colleague* colleague) {
23        for (auto c : colleagues) {
24            if (c != colleague) {
25                c->receive(message);
26            }
27        }
28    }
29
30private:
31    vector<Colleague*> colleagues;
32};
33
34// 抽象同事类
35class Colleague {
36public:
37    Colleague(Mediator* mediator) : mediator(mediator) {}
38
39    virtual void send(string message) = 0;
40    virtual void receive(string message) = 0;
41
42protected:
43    Mediator* mediator;
44};
45
46// 具体同事类
47class ConcreteColleagueA : public Colleague {
48public:
49    ConcreteColleagueA(Mediator* mediator) : Colleague(mediator) {}
50
51    void send(string message) {
52        mediator->send(message, this);
53    }
54
55    void receive(string message) {
56        cout << "ConcreteColleagueA received message: " << message << endl;
57    }
58};
59
60class ConcreteColleagueB : public Colleague {
61public:
62    ConcreteColleagueB(Mediator* mediator) : Colleague(mediator) {}
63
64    void send(string message) {
65        mediator->send(message, this);
66    }
67
68    void receive(string message) {
69        cout << "ConcreteColleagueB received message: " << message << endl;
70    }
71};
72
73int main() {
74    ConcreteMediator* mediator = new ConcreteMediator();
75    ConcreteColleagueA* colleagueA = new ConcreteColleagueA(mediator);
76    ConcreteColleagueB* colleagueB = new ConcreteColleagueB(mediator);
77    vector<Colleague*> colleagues = {colleagueA, colleagueB};
78    mediator->setColleague(colleagues);
79
80    colleagueA->send("Hello, colleagueB!");
81    colleagueB->send("Hi, colleagueA!");
82
83    delete colleagueA;
84    delete colleagueB;
85    delete mediator;
86
87    return 0;
88}

 1#include <string>
 2#include <iostream>
 3#include <boost/signals2.hpp>
 4
 5using namespace std;
 6using namespace boost;
 7
 8struct EventData
 9{
10    virtual ~EventData() = default;
11    virtual void print() const = 0;
12};
13
14struct PlayerScoreData : EventData
15{
16    string player_name;
17    int goals_scored_so_far;
18
19    PlayerScoreData(string player_name, const int goals_scored_so_far) :
20            player_name(std::move(player_name)), goals_scored_so_far(goals_scored_so_far)
21    {}
22
23    void print() const override
24    {
25        cout << player_name << "has scored! (their "
26             << goals_scored_so_far << "goal)" << "\n";
27    }
28};
29
30struct Game
31{
32    signals2::signal<void(EventData *)> events;
33};
34
35struct Player
36{
37    string name;
38    int goals_scored = 0;
39    Game &game;
40
41    Player(string name, Game &game) :
42            name(std::move(name)), game(game)
43    {}
44
45    void score()
46    {
47        goals_scored++;
48        PlayerScoreData ps{name, goals_scored};
49        game.events(&ps);
50    }
51};
52
53struct Coach
54{
55    Game &game;
56
57    explicit Coach(Game &game) : game(game)
58    {
59        game.events.connect([](EventData *e) {
60            auto *ps = dynamic_cast<PlayerScoreData *>(e);
61            if (ps && ps->goals_scored_so_far < 3) {
62                cout << "coach says: well done, " << ps->player_name << "\n";
63            }
64        });
65    }
66};
67
68int main()
69{
70    Game game;
71    Player player{"helywin", game};
72    Coach coach{game};
73    player.score();
74    player.score();
75    return 0;
76}

 1Memento deposit(int amount)
 2{
 3    balance += amount;
 4    return { balance };
 5}
 6
 7class Memento
 8{
 9    int balance;
10}
11
12BankAccount ba{ 100 };
13auto m1 = ba.deposit(50);
14auto m2 = ba.deposit(25);
15cout << ba << "\n"; // Balance: 175
16
17// undo to m1
18ba.restore(m1);
19cout << ba << "\n"; // Balance: 150
20
21// redo
22ba.restore(m2);
23cout << ba << "\n"; // Balance: 175

1shared_ptr<int> n;
2int x = *n + 1;

 1#include <memory>
 2#include <string>
 3#include <iostream>
 4
 5using namespace std;
 6
 7struct Logger
 8{
 9    virtual ~Logger() = default;
10    virtual void info(const string &s) = 0;
11    virtual void warn(const string &s) = 0;
12};
13
14struct ConsoleLogger : Logger
15{
16    void info(const string &s) override
17    {
18        cout << "Info: " << s << endl;
19    }
20
21    void warn(const string &s) override
22    {
23        cout << "Warn: " << s << endl;
24    }
25};
26
27struct NullLogger : Logger
28{
29    void info(const string &s)
30    {};
31
32    void warn(const string &s)
33    {};
34};
35
36struct OptionalLogger : Logger
37{
38    shared_ptr<Logger> impl;
39    static shared_ptr<Logger> no_logging;
40
41    explicit OptionalLogger(const shared_ptr<Logger> &logger) : impl{logger}
42    {}
43
44    virtual void info(const string &s) override
45    {
46        if (impl) impl->info(s);
47    }
48
49    virtual void warn(const string &s) override
50    {
51        if (impl) impl->warn(s);
52    }
53};
54
55shared_ptr<Logger> OptionalLogger::no_logging{};
56
57struct User
58{
59    string name;
60    shared_ptr<OptionalLogger> logger;
61
62    explicit User(string name, const shared_ptr<Logger> &logger = OptionalLogger::no_logging) :
63            name(std::move(name)),
64            logger{make_shared<OptionalLogger>(logger)}
65    {}
66
67    void log()
68    {
69        logger->info(name);
70    }
71
72};
73
74int main()
75{
76    User u1("u1");
77    u1.log();
78    shared_ptr<ConsoleLogger> logger = make_shared<ConsoleLogger>();
79    User u2("u2", logger);
80    u2.log();
81    return 0;
82}

 1#include <iostream>
 2#include <vector>
 3using namespace std;
 4
 5class Observer {
 6public:
 7    virtual void update(int data) = 0;
 8};
 9
10class Subject {
11public:
12    void attach(Observer* observer) {
13        observers.push_back(observer);
14    }
15    void detach(Observer* observer) {
16        for (auto it = observers.begin(); it != observers.end(); ++it) {
17            if (*it == observer) {
18                observers.erase(it);
19                return;
20            }
21        }
22    }
23    void notify(int data) {
24        for (auto observer : observers) {
25            observer->update(data);
26        }
27    }
28private:
29    vector<Observer*> observers;
30};
31
32class ConcreteObserver : public Observer {
33public:
34    ConcreteObserver(string name) : name(name) {}
35    void update(int data) override {
36        cout << "Observer " << name << " received data: " << data << endl;
37    }
38private:
39    string name;
40};
41
42class ConcreteSubject : public Subject {
43public:
44    void setData(int data) {
45        this->data = data;
46        notify(data);
47    }
48private:
49    int data;
50};
51
52int main() {
53    ConcreteSubject subject;
54    ConcreteObserver observer1("Observer 1");
55    ConcreteObserver observer2("Observer 2");
56    subject.attach(&observer1);
57    subject.attach(&observer2);
58    subject.setData(10);
59    subject.detach(&observer1);
60    subject.setData(20);
61    return 0;
62}