C++ 中两个类之间的通信方式

C++ 中两个类之间的通信

在 C++ 中，两个类之间可以通过多种方式进行通信。以下是几种常见的方法：

1. 包含/组合（Composition）

一个类包含另一个类的对象作为成员：

class ClassB {
public:
    void methodB() {
        cout << "ClassB method" << endl;
    }
};

class ClassA {
private:
    ClassB b;  // ClassA 包含 ClassB 对象
public:
    void methodA() {
        b.methodB();  // 调用 ClassB 的方法
    }
};

2. 指针/引用成员

一个类持有另一个类的指针或引用：

class ClassB {
public:
    void methodB() { /* ... */ }
};

class ClassA {
private:
    ClassB* bPtr;  // 指针成员
public:
    ClassA(ClassB* b) : bPtr(b) {}
    void methodA() {
        bPtr->methodB();
    }
};

3. 友元类（Friend Class）

使用 friend 关键字允许一个类访问另一个类的私有成员：

class ClassB {
private:
    int secretData;
    friend class ClassA;  // 声明 ClassA 为友元
};

class ClassA {
public:
    void accessB(ClassB& b) {
        b.secretData = 42;  // 可以访问 ClassB 的私有成员
    }
};

4. 通过参数传递

通过方法参数传递对象：

class ClassB {
public:
    void methodB() { /* ... */ }
};

class ClassA {
public:
    void callB(ClassB& b) {
        b.methodB();
    }
};

5. 观察者模式（Observer Pattern）

用于实现发布-订阅机制：

#include <vector>
#include <algorithm>

class Observer {
public:
    virtual void update() = 0;
};

class Subject {
private:
    std::vector<Observer*> observers;
public:
    void attach(Observer* obs) {
        observers.push_back(obs);
    }
    void notify() {
        for (auto obs : observers) {
            obs->update();
        }
    }
};

class ConcreteObserver : public Observer {
public:
    void update() override {
        cout << "Received update notification" << endl;
    }
};

6. 中介者模式（Mediator Pattern）

通过中介者类来协调多个类之间的通信：

class Mediator;  // 前向声明

class Colleague {
protected:
    Mediator* mediator;
public:
    Colleague(Mediator* m) : mediator(m) {}
};

class Mediator {
public:
    virtual void notify(Colleague* sender, std::string event) = 0;
};

class ConcreteColleagueA : public Colleague {
public:
    ConcreteColleagueA(Mediator* m) : Colleague(m) {}
    void doSomething() {
        mediator->notify(this, "Event from A");
    }
};

选择建议

• 对于简单关系，使用组合或参数传递

• 需要访问私有成员时考虑友元（但应谨慎使用）

• 对于复杂通信或解耦需求，考虑观察者或中介者模式

• 避免过度使用友元，因为它会破坏封装性

每种方法都有其适用场景，应根据具体需求选择最合适的通信方式。