1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Tom
{
public:
    
    void Miaow() 
    {
        cout << "喵!" << endl;
    }
    
    ... 
};

class Jerry
{
public:
    
    void RunAway()
    {
        cout << "那只猫又来了，快溜！" << endl;
    }
    
    ... 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

int main(int argc, char *argv[])
{
    
    Tom tom;

    
    Jerry jerry;

    
    tom.Miaow();

    
    jerry.RunAway();

    return 0;
}

1

std::map<std::string, std::function<void()>> callbackMap;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class Connections 
{
public:
    
    void connect(const std::string &name, const std::function<void()> &callback) 
    {
        m_callbackMap[name] = callback;
    }
    
    void invok(const std::string &name)
    {
        auto it = m_callbackMap.find(name);
        
        if (it != m_callbackMap.end()) {
            
            it->second();
        }
    }
private:
    std::map<std::string, std::function<void()>> m_callbackMap;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

static Connections s_connections;


class Tom
{
public:
    
    void Miaow() 
    {
        cout << "喵!" << endl;
        
        s_connections.invok("mouse");
    }
    
    ... 
};

class Jerry
{
public:
    Jerry() 
    {
        
        s_connections.connect("mouse", std::bind(&Jerry::RunAway, this));
    }
    
    void RunAway()
    {
        cout << "那只猫又来了，快溜！" << endl;
    }
    
    ... 
};
int main(int argc, char *argv[])
{
    
    struct A {
        struct B {
            struct C {
                private:
                    
                    Tom tom;
                public:
                    void MiaoMiaoMiao() 
                    {
                        tom.Miaow();
                    }
            }c;
            void MiaoMiao() 
            {
                c.MiaoMiaoMiao();
            }
        }b;
        void Miao() 
        {
            b.MiaoMiao();
        }
    }a;
    
    struct D {
        struct E {
            struct F {
                private:
                    
                    Jerry jerry;
            }f;
        }e;
    }d;

    
    a.Miao();
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#pragma once
#include <vector>
#include <algorithm>


template<typename ObserverType>
class Subject {
public:
    
    void subscibe(ObserverType *obs)
    {
        auto itor = std::find(m_observerList.begin(), m_observerList.end(), obs);
        if (m_observerList.end() == itor) {
            m_observerList.push_back(obs);
        }
    }
    
    void unSubscibe(ObserverType *obs)
    {
        m_observerList.erase(std::remove(m_observerList.begin(), m_observerList.end(), obs));
    }
    
    template <typename FuncType>
    void publish(FuncType func)
    {
        for (auto obs: m_observerList)
        {
            
            func(obs);
        }
    }
private:
    std::vector<ObserverType *> m_observerList;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#include "Subject.hpp"
#include <functional>
#include <iostream>

using std::cout;
using std::endl;


class CatObserver {
public:
    
    virtual void onMiaow() = 0;
public:
    virtual ~CatObserver() {}
};


class Tom : public Subject<CatObserver>
{
public:
    void miaoW()
    {
        cout << "喵!" << endl;
        
        
        
        publish(std::bind(&CatObserver::onMiaow, std::placeholders::_1));
    }
};

class Jerry: public CatObserver
{
public:
    
    void onMiaow() override
    {
        
        RunAway();
    }
    void RunAway()
    {
        cout << "那只猫又来了，快溜！" << endl;
    }
};
int main(int argc, char *argv[])
{
    Tom tom;
    Jerry jerry;

    
    tom.subscibe(&jerry);

    tom.miaoW();
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Tom {
public:
    Tom() {}
    const std::string & getName() const
    {
        return m_name;
    }
    void setName(const std::string &name) 
    {
        m_name = name;
    }
private:
    std::string m_name;
};