设计模式

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

// c++11后是线程安全的 （
class Singleton {
private:
    Singleton(){}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton& GetInstance() {
        static Singleton singleton;
        return singleton;
    }
};

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

// 饿汉式
class Singlehungry {
private:
    Singlehungry(){}
    Singlehungry(const Singlehungry&) = delete;
    Singlehungry& operator=(const Singlehungry&) = delete;
public:
    static Singlehungry* GetInstance() {
        if (singleton == nullptr) {
            singleton = new Singlehungry();
        }
        return singleton;
    }
private:
    static Singlehungry* singleton;
};
// 饿汉式初始化
Singlehungry* Singlehungry::singleton = Singlehungry::GetInstance();

 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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

// 懒汉式
class SingleLazy {
private:
    SingleLazy(){}
    SingleLazy(const SingleLazy&) = delete;
    SingleLazy& operator=(const Singlehungry&) = delete;
public:
    static SingleLazy* GetInstance() {
        if(singleton != nullptr) {
            return singleton;
        }
        _mutex.lock();
        if (singleton != nullptr) {
            _mutex.unlock();
            return singleton;
        }
        singleton = new SingleLazy();
        _mutex.unlock();
        return singleton;
        
    }
private:
    static SingleLazy* singleton;
    static std::mutex _mutex;
};

SingleLazy* SingleLazy::singleton = nullptr;
std::mutex SingleLazy::_mutex;

// 懒汉式 智能指针 自动回收
class SingleAuto {
private:
    SingleAuto(){}
    SingleAuto(const SingleAuto&) = delete;
    SingleAuto& operator=(const SingleAuto&) = delete;
public:
    ~SingleAuto() {std::cout << "single auto delete success " << std::endl; }
    static std::shared_ptr<SingleAuto> GetInstance() {
        if(singleton != nullptr) {
            return singleton;
        }
        _mutex.lock();
        if (singleton != nullptr) {
            _mutex.unlock();
            return singleton;
        }
        singleton = std::shared_ptr<SingleAuto>(new SingleAuto);
        _mutex.unlock();
        return singleton;
        
    }
private:
    static std::shared_ptr<SingleAuto> singleton;
    static std::mutex _mutex;
};

std::shared_ptr<SingleAuto> SingleAuto::singleton = nullptr;
std::mutex SingleAuto::_mutex;
// 定义友元类帮忙回收
class SingleAutoSafe;
class SafeDeletor {
public:
	void operator()(SingleAutoSafe* sf) {
		std::cout << "this is safe deleter operator()" << std::endl;
		delete sf;
	}
};
class SingleAutoSafe {
private:
    SingleAutoSafe(){}
    SingleAutoSafe(const SingleAutoSafe&) = delete;
    SingleAutoSafe& operator=(const SingleAutoSafe&) = delete;
    ~SingleAutoSafe() {std::cout << "single auto delete success " << std::endl; }
    friend class SafeDeletor;
public:
    static std::shared_ptr<SingleAutoSafe> GetInstance() {
        if(singleton != nullptr) {
            return singleton;
        }
        _mutex.lock();
        if (singleton != nullptr) {
            _mutex.unlock();
            return singleton;
        }
        singleton = std::shared_ptr<SingleAutoSafe>(new SingleAutoSafe, SafeDeletor());
        _mutex.unlock();
        return singleton;
        
    }
private:
    static std::shared_ptr<SingleAutoSafe> singleton;
    static std::mutex _mutex;
};

std::shared_ptr<SingleAutoSafe> SingleAutoSafe::singleton = nullptr;
std::mutex SingleAutoSafe::_mutex;

 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

class SingleOnce {
private:
    SingleOnce() = default;
    SingleOnce(const SingleOnce&) = delete;
    SingleOnce& operator=(const SingleOnce&) = delete;
public:
    static std::shared_ptr<SingleOnce> GetInstance() {
        static std::once_flag _flag;
        std::call_once(_flag, [&](){
            singleton = std::shared_ptr<SingleOnce>(new SingleOnce);
        });
        return singleton;
    }
    ~SingleOnce() {std::cout << "this is singleton destruct" << std::endl;}
private:
    static std::shared_ptr<SingleOnce> singleton;
};

std::shared_ptr<SingleOnce> SingleOnce::singleton = nullptr;

// 通用模板类
template <typename T>
class Singleton {
protected:
	Singleton() = default;
	Singleton(const Singleton<T>&) = delete;
	Singleton& operator=(const Singleton<T>& st) = delete;
public:
	static std::shared_ptr<T> GetInstance() {
		static std::once_flag _flag;
		std::call_once(_flag, [&]() {
			_instance = std::shared_ptr<T>(new T);
			});
		return _instance;
	}
	void PrintAddress() {
		std::cout << _instance.get() << std::endl;
	}
	~Singleton() {std::cout << "this is singleton destruct" << std::endl;}
private:
    static std::shared_ptr<T> _instance;
};
template <typename T>
std::shared_ptr<T> Singleton<T>::_instance = nullptr;

 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

class ImageReader {
public:
    virtual void readImage(const std::string& filepath) = 0;
    virtual ~ImageReader(){}
};

class GIFReader: public ImageReader {
public:
    void readImage(const std::string& filepath) override {
        std::cout << "Reading GIF image from file: " << filepath << std::endl;
    }
};

class JPGReader: public ImageReader {
public:
    void readImage(const std::string& filepath) override {
        std::cout << "Reading JPG image from file: " << filepath << std::endl;
    }
};

class ImageReaderFactory {
public:
    virtual ImageReader* createReader() = 0;
    virtual ~ImageReaderFactory(){}
};

class GIFReaderFactory: public ImageReaderFactory {
public:
    ImageReader* createReader() override {
        return new GIFReader();
    }
};

class JPGReaderFactory: public ImageReaderFactory {
public:
    ImageReader* createReader() override {
        return new JPGReader();
    }
};

 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

// 操作控制类：抽象产品类A
class OperationController {
public:
    virtual void controlGame() = 0;
    virtual ~OperationController(){}
};

// 界面控制类：抽象产品类B
class InterfaceController {
public:
    virtual void displayInterface() = 0;
};

// 具体产品类A1
class iOSOperationController : public OperationController {
public:
    void controlGame() override {
        std::cout << "ios control game" << std::endl;
    }
};

// 具体产品类A2
class AndroidOperationController : public OperationController {
public:
    void controlGame() override {
        std::cout << "android control game" << std::endl;
    }
};

// 具体产品类B1
class iOSInterfaceController : public InterfaceController {
public:
    void displayInterface() override {
        std::cout << "ios display" << std::endl;
    }
};

// 具体产品类B2
class AndroidInterfaceController : public InterfaceController {
public:
    void displayInterface() override {
        std::cout << "android display" << std::endl;
    }
};

// 抽象工厂类
class AbstractFactory {
public:
    virtual OperationController* createOperationController() = 0;
    virtual InterfaceController* createInterfaceController() = 0;
    virtual ~AbstractFactory() {}
};

// iOS工厂 ：具体工厂1
class iOSFactory : public AbstractFactory {
public:
    OperationController* createOperationController() override {
        return new iOSOperationController();
    }
    InterfaceController* createInterfaceController() override {
        return new iOSInterfaceController();
    }
};

// Android工厂 ：具体工厂2
class AndroidFactory : public AbstractFactory {
public:
    OperationController* createOperationController() override {
        return new AndroidOperationController();
    }
    InterfaceController* createInterfaceController() override {
        return new AndroidInterfaceController();
    }
};

 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

class ComputerComponent {
public:
    virtual ~ComputerComponent() {}
    virtual void display() = 0;
};
class CPU : public ComputerComponent {
public:
    void display() override { std::cout << "\tCPU \n"; }
};

class GPU : public ComputerComponent {
public:
    void display() override { std::cout << "\tGPU \n"; }
};

class ARM : public ComputerComponent {
public:
    void display() override { std::cout << "\tARM \n"; }
};


// 抽象建造者类
class Builder {
public:
    virtual void buildCPU() = 0;
    virtual void buildGPU() = 0;
    virtual void buildRAM() = 0;
    virtual std::vector<ComputerComponent*> getResult() = 0;
    virtual ~Builder() {}
};

// 具体建造者类
class ComputerBuilder : public Builder {
public:
    void buildCPU() override { components.push_back(new CPU()); }
    void buildGPU() override { components.push_back(new GPU()); }
    void buildRAM() override { components.push_back(new ARM()); }
    std::vector<ComputerComponent*> getResult() override { return components; }
private:
    std::vector<ComputerComponent*> components;
};

// 指挥者类
class Director {
public:
    void construct(Builder* builder) {
        builder->buildCPU();
        builder->buildGPU();
        builder->buildRAM();
    }
};

 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

class Address {
public:
    Address(const std::string& s, const std::string& c, const std::string& co)
        : street(s), city(c), country(co) {}

    Address(const Address& other)
        : street(other.street), city(other.city), country(other.country) {}\
	~Address() {} 
public:
    std::string street;
    std::string city;
    std::string country;
};
// 抽象原型类
class Customer {
public:
    Customer(const std::string& n, Address* addr)
        : name(n), address(addr) {}

    // 原型模式中的克隆接口
    virtual Customer* clone() const = 0;
    virtual ~Customer(){}

public:
    std::string name;
    Address* address;
};

// 浅克隆
class ShallowCopyCustomer : public Customer {
public:
    ShallowCopyCustomer(const std::string& n, Address* addr)
        : Customer(n, addr) {}

    ShallowCopyCustomer(const ShallowCopyCustomer& other)
        : Customer(other.name, other.address) {}

    Customer* clone() const override {
        return new ShallowCopyCustomer(*this);
    }
};

// 深克隆
class DeepCopyCustomer : public Customer {
public:
    DeepCopyCustomer(const std::string& n, Address* addr)
        : Customer(n, addr) {}

    DeepCopyCustomer(const DeepCopyCustomer& other)
        : Customer(other.name, new Address(*other.address)) {}

    Customer* clone() const override {
        return new DeepCopyCustomer(*this);
    }
};

 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

// Target:request 目标接口：加密解密接口
class EncryptorInterface {
public:
    virtual ~EncryptorInterface() {}
    virtual void encrypt() = 0;
    virtual void decrypt() = 0;
};

// Adaptee:specificRequest 第三方加密类
class ThirdPartyEncryptor {
public:
    void encrypt() {
        std::cout << "ThirdParty Encrypted !\n";
    }
    void decrypt() {
        std::cout << "ThirdParty Decrypted !\n";
    }
};

// Adapter:request
class EncryptorAdapter : public EncryptorInterface {
public:
    EncryptorAdapter() {}
    void encrypt() override {
        _thirdPartyEncryptor.encrypt();
    }
    void decrypt() override {
        _thirdPartyEncryptor.decrypt();
    }
private:
    ThirdPartyEncryptor _thirdPartyEncryptor;
};

 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

class DatabaseAccess;
class DataConverter {
public:
    DataConverter(DatabaseAccess* db) : database(db) {}
    virtual ~DataConverter() {}
    virtual void convertToFile(const std::string& filePath) = 0;
protected:
    DatabaseAccess* database; // 引用数据库访问层，实现桥接
};

// 数据库访问抽象接口
class DatabaseAccess {
public:
    virtual ~DatabaseAccess() {}
    virtual void fetchRecords() = 0;
};

class MySQLDatabase : public DatabaseAccess {
public:
    void fetchRecords() override {
        std::cout << "MySQLDatabase data records ";
    }
};

class PostgreSQLDatabase : public DatabaseAccess {
public:
    void fetchRecords() override {
       std::cout << "PostgreSQLDatabase data records ";
    }
};

class TXTConverter : public DataConverter {
public:
    TXTConverter(DatabaseAccess* db) : DataConverter(db) {}
    void convertToFile(const std::string& filePath) override {
        database->fetchRecords(); 
        std::cout << "convert to txt\n";
    }
};

class XMLConverter : public DataConverter {
public:
    XMLConverter(DatabaseAccess* db) : DataConverter(db) {}
    void convertToFile(const std::string& filePath) override {
        database->fetchRecords();
        std::cout << "convert to xml\n";
    }
};

 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

class Component {
public:
    virtual ~Component() {}
    virtual void add(std::shared_ptr<Component>) = 0;
    virtual void remove(std::shared_ptr<Component>) = 0;
    virtual void display(int depth = 0) const = 0;
};

class Button : public Component {
public:
    void add(std::shared_ptr<Component>) override { /* 不允许添加子控件 */ }
    void remove(std::shared_ptr<Component>) override { /* 不允许删除子控件 */ }
    void display(int depth) const override {
        std::cout << std::string(depth * 2, '-') << "Button\n";
    }
};

class TextBox : public Component {
public:
    void add(std::shared_ptr<Component>) override { /* 不允许添加子控件 */ }
    void remove(std::shared_ptr<Component>) override { /* 不允许删除子控件 */ }
    void display(int depth) const override {
        std::cout << std::string(depth * 2, '-') << "TextBox\n";
    }
};

class Panel : public Component {
public:
    void add(std::shared_ptr<Component> child) override {
        children.push_back(child);
    }

    void remove(std::shared_ptr<Component> child) override {
        children.erase(
            std::remove_if(children.begin(), children.end(),
                           [&](const std::shared_ptr<Component>& c) { return c == child; }),
            children.end());
    }

    void display(int depth) const override {
        std::cout << std::string(depth * 2, '-') << "Panel\n";
        for (const auto& child : children) {
            child->display(depth + 1);
        }
    }
private:
    std::vector<std::shared_ptr<Component>> children;
};

 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

// Component 抽象组件：定义了加密接口
class Encryptor {
public:
    virtual ~Encryptor() {}
    virtual std::string encrypt(const std::string &input) const = 0;
};

// ConcreteComponent 具体组件：原始字符串，没有加密
class PlainText : public Encryptor {
public:
    std::string encrypt(const std::string &input) const override {
        return input; 
    }
};

// Decorator 抽象装饰器：继承自 Encryptor，为装饰器定义接口
class EncryptDecorator : public Encryptor {
public:
    explicit EncryptDecorator(std::unique_ptr<Encryptor> encryptor)
        : m_encryptor(std::move(encryptor)) {}

    std::string encrypt(const std::string &input) const override {
        return m_encryptor->encrypt(input);
    }
private:
    std::unique_ptr<Encryptor> m_encryptor;
};

// ConcreteDecoratorA 具体装饰器：移位加密
class ShiftEncryptor : public EncryptDecorator {
public:
    explicit ShiftEncryptor(std::unique_ptr<Encryptor> encryptor)
        : EncryptDecorator(std::move(encryptor)) {}

    std::string encrypt(const std::string &input) const override {
        std::string encrypted = EncryptDecorator::encrypt(input);
        for (char &c : encrypted) {
            if (isalpha(c)) {
                c = (c >= 'a' && c <= 'z') ? ((c - 'a' + 3) % 26 + 'a')
                                          : ((c - 'A' + 3) % 26 + 'A');
            }
        }
        return encrypted;
    }
};

 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

// 通讯录备份实现
class ContactsBackup {
public:
    bool backup() {
        std::cout << "Backing up contacts...\n";
        return true;
    }
};

// 短信备份实现
class SMSBackup {
public:
    bool backup() {
        std::cout << "Backing up SMS...\n";
        return true;
    }
};

class BackupFacade {
public:
    BackupFacade(ContactsBackup *contacts_backup = nullptr, SMSBackup *sms_backup = nullptr) {
        this->contacts_backup_ = contacts_backup ? : new ContactsBackup;
        this->sms_backup_ = sms_backup ? : new SMSBackup;
    }
    ~BackupFacade() {
        delete contacts_backup_;
        delete sms_backup_;
    }
    bool oneClickBackup() {
        std::cout << "Starting one-click backup...\n";
        bool backupSuccess = 
            this->contacts_backup_->backup() &&
            this->sms_backup_->backup();
           
        if (backupSuccess) {
            std::cout << "One-click backup completed successfully.\n";
        } else {
            std::cout << "One-click backup failed.\n";
        }
        return backupSuccess;
    }
private:
    ContactsBackup *contacts_backup_;
    SMSBackup *sms_backup_;
};

 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

// FlyWeight 抽象享元类
class Media {
public:
    virtual void display(int x, int y, int width, int height) const = 0;
    virtual ~Media() = default;
};

// 具体享元类 - 图片
class Image : public Media {
private:
    std::string filename;
public:
    Image(const std::string& filename) : filename(filename) {}
    void display(int x, int y, int width, int height) const override {
        std::cout << "Displaying image " << filename 
                  << " at (" << x << ", " << y 
                  << "), size: (" << width << "x" << height << ").\n";
    }
};

// 具体享元类 - 视频
class Video : public Media {
private:
    std::string filename;
public:
    Video(const std::string& filename) : filename(filename) {}
    void display(int x, int y, int width, int height) const override {
        std::cout << "Playing video " << filename 
                  << " at (" << x << ", " << y 
                  << "), size: (" << width << "x" << height << ").\n";
    }
};

// FlyweightFactory
class MediaFactory {
public:
    std::shared_ptr<Media> getMedia(const std::string& type, const std::string& filename) {
        std::string key = type + ":" + filename;
        if (mediaPool.find(key) == mediaPool.end()) {
            if (type == "image") {
                mediaPool[key] = std::make_shared<Image>(filename);
            } else if (type == "video") {
                mediaPool[key] = std::make_shared<Video>(filename);
            }
        }
        return mediaPool[key];
    }
private:
    std::unordered_map<std::string, std::shared_ptr<Media>> mediaPool;
};

 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

// Subject 抽象主题
class Image {
public:
    virtual void display() = 0;
    virtual ~Image() = default;
};
// RealSubject 真实主题 网络图片
class RealImage : public Image {
public:
    RealImage(const std::string& filename) : file_name{filename} {}
    void display() override {
        std::cout << "display image: " << file_name << ".\n";
    }
private:
    std::string file_name;
};
// Proxy 图标代理
class IconProxy : public Image {
public:
    IconProxy(const std::string& filename) : file_name(filename) {}

    void display() override {
        if (real_subject_ == nullptr) {
            real_subject_ = std::make_unique<RealImage>(file_name);
        }
        std::cout << "Displaying icon for image: " << file_name << std::endl;
        real_subject_->display();
    }

private:
    std::string file_name;
    std::unique_ptr<RealImage> real_subject_;
};
// ImageManager 管理所有URL及其图片集合
class ImageManager {
public:
    void addImage(const std::string& url, const std::string& filename) {
        view_url[url].emplace(std::make_unique<IconProxy>(filename));
    }

    const std::set<std::unique_ptr<Image>>& getImagesForUrl(const std::string& url) const {
        return view_url.at(url);
    }

private:
    std::unordered_map<std::string, std::set<std::unique_ptr<Image>>> view_url;
};
// ImageViewer 显示特定URL的图片
class ImageViewer {
public:
    ImageViewer(const std::string& url, const ImageManager& manager) : url{url}, manager{manager} {}

    void displayImages() {
        const auto& images = manager.getImagesForUrl(url);
        for (const auto& image : images) {
            image->display();
            std::cout << "\n";
        }
    }

private:
    std::string url;
    const ImageManager& manager;
};

 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

// 抽象处理者
class Approver {
public:
    virtual void processLeaveApplication(int days) = 0;
    virtual ~Approver() = default;
};

// 具体处理者：主任
class Director : public Approver {
public:
    void processLeaveApplication(int days) override {
        if (days < 3) {
            std::cout << "Director approved the leave application." << std::endl;
        } else {
            std::cout << "Director cannot approve, passing to next approver." << std::endl;
            if (nextApprover) {
                nextApprover->processLeaveApplication(days);
            }
        }
    }

    void setNextApprover(Approver* next) {
        nextApprover = next;
    }

private:
    Approver* nextApprover = nullptr;
};

// 具体处理者：经理
class Manager : public Approver {
public:
    void processLeaveApplication(int days) override {
        if (days >= 3 && days < 10) {
            std::cout << "Manager approved the leave application." << std::endl;
        } else {
            std::cout << "Manager cannot approve, passing to next approver." << std::endl;
            if (nextApprover) {
                nextApprover->processLeaveApplication(days);
            }
        }
    }

    void setNextApprover(Approver* next) {
        nextApprover = next;
    }

private:
    Approver* nextApprover = nullptr;
};

// 具体处理者：总经理
class GeneralManager : public Approver {
public:
    void processLeaveApplication(int days) override {
        if (days >= 10 && days < 30) {
            std::cout << "General Manager approved the leave application." << std::endl;
        } else if (days >= 30) {
            std::cout << "Leave application rejected: too many days requested." << std::endl;
        } else {
            std::cout << "General Manager cannot approve, passing to next approver." << std::endl;
            if (nextApprover) {
                nextApprover->processLeaveApplication(days);
            }
        }
    }

    void setNextApprover(Approver* next) {
        nextApprover = next;
    }

private:
    Approver* nextApprover = nullptr;
};

 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

class Command {
public:
    virtual ~Command() {}
    virtual void execute() = 0;
};
// Receiver 接收者
class BoardScreen {
public:
    void open() {
        std::cout << "Opening board screen" << std::endl;
    }

    void create() {
        std::cout << "Creating board content" << std::endl;
    }

    void edit() {
        std::cout << "Editing board content" << std::endl;
    }
};
// ConcreteCommand 具体命令类
class OpenCommand : public Command {
public:
    OpenCommand(BoardScreen* screen) : boardScreen(screen) {}
    void execute() override {
        boardScreen->open();
    }
private:
    BoardScreen* boardScreen;
};

class CreateCommand : public Command {
public:
    CreateCommand(BoardScreen* screen) : boardScreen(screen) {}
    void execute() override {
        boardScreen->create();
    }
private:
    BoardScreen* boardScreen;
};

class EditCommand : public Command {
public:
    EditCommand(BoardScreen* screen) : boardScreen(screen) {}
    void execute() override {
        boardScreen->edit();
    }
private:
    BoardScreen* boardScreen;
};

// Invoker 调用者
class MenuItem {
public:
    void setCommand(Command* command) {
        this->command = command;
    }

    void click() {
        if (command) {
            command->execute();
        }
    }

private:
    Command* command = nullptr;
};

 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

template <typename T, typename U>
class PageIterator {
public:
    typedef typename std::vector<T>::iterator iter_type;

    PageIterator(U *p_data, size_t page_size, size_t page_index)
        : m_p_data_(p_data), page_size_(page_size), current_index_(page_index * page_size) {
        m_it_ = m_p_data_->m_data_.begin() + current_index_;
    }

    void NextPage() {
        current_index_ += page_size_;
        m_it_ = m_p_data_->m_data_.begin() + current_index_;
    }

    bool IsDone() {
        return current_index_ >= m_p_data_->m_data_.size();
    }

    std::vector<T> CurrentPage() {
        std::vector<T> page_elements;
        size_t remaining = std::min(page_size_, m_p_data_->m_data_.size() - current_index_);
        for (size_t i = 0; i < remaining; ++i) {
            page_elements.push_back(*m_it_);
            ++m_it_;
        }
        return page_elements;
    }

private:
    U *m_p_data_;           // 指向分页容器的指针
    iter_type m_it_;       // 当前迭代器位置
    size_t page_size_;
    size_t current_index_;
};

template <class T>
class PaginatedContainer {
    friend class PageIterator<T, PaginatedContainer<T>>;

public:
    void Add(T a) {
        m_data_.push_back(a);
    }

    size_t Size() const {
        return m_data_.size();
    }

    PageIterator<T, PaginatedContainer<T>> CreatePageIterator(size_t page_size, size_t page_index = 0) {
        return PageIterator<T, PaginatedContainer<T>>(this, page_size, page_index);
    }

private:
    std::vector<T> m_data_;
};

 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
76
77
78
79
80
81
82
83
84
85

class Pane;
// 中介者接口
class Mediator {
public:
    virtual ~Mediator() {}
    virtual void PaneChanged(Pane* pane) = 0;
};

// 窗格基类或接口
class Pane {
public:
    virtual ~Pane() {}
    virtual void SetMediator(Mediator* mediator) = 0;
    virtual void Update() = 0;
protected:
    bool updating = false;
};

// 具体窗格类 TextPane
class TextPane : public Pane {
public:
    void SetMediator(Mediator* mediator) override {
        this->mediator = mediator;
    }

    void Update() override {
        if (!updating) { 
            updating = true; 
            mediator->PaneChanged(this);
            updating = false;
        }
    }

private:
    Mediator* mediator;
};

// 具体窗格类 ListPane
class ListPane : public Pane {
public:
    void SetMediator(Mediator* mediator) override {
        this->mediator = mediator;
    }

    void Update() override {
        if (!updating) { 
            updating = true; 
            mediator->PaneChanged(this);
            updating = false;
        }
    }

private:
    Mediator* mediator;
};

// 具体中介者类 WindowMediator
class WindowMediator : public Mediator {
public:
    void AddPane(Pane* pane) {
        panes.push_back(pane);
        pane->SetMediator(this);
    }

    void PaneChanged(Pane* pane) override {
        if (dynamic_cast<TextPane*>(pane)) {
            std::cout << "Text Pane updated. Updating other panes as needed." << std::endl;
        } else if (dynamic_cast<ListPane*>(pane)) {
            std::cout << "List Pane updated. Updating other panes as needed." << std::endl;
        }
        NotifyOtherPanes();
    }

private:
    void NotifyOtherPanes() {
        for (Pane* p : panes) {
            if (p != currentPane) {
                p->Update();
            }
        }
    }

    std::vector<Pane*> panes;
    Pane* currentPane = nullptr;
};