C++笔记之两个类的实例之间传递参数的各种方法

笑鸿的学习笔记2023-08-09 21:59

C++笔记之两个类的实例之间传递参数的各种方法

code review!

文章目录

1.构造函数参数传递

代码

cpp 复制代码 
class ClassA {
public:
    ClassA(int value) : memberA(value) {}
private:
    int memberA;
};

class ClassB {
public:
    ClassB(const ClassA& aInstance) : memberB(aInstance) {}
private:
    ClassA memberB;
};

int main() {
    ClassA objA(42);
    ClassB objB(objA);
    return 0;
}

2.成员函数参数传递

代码

cpp 复制代码 
class ClassA {
public:
    ClassA(int value) : memberA(value) {}
    int getValue() const { return memberA; }
private:
    int memberA;
};

class ClassB {
public:
    void doSomethingWithA(const ClassA& aInstance) {
        int value = aInstance.getValue();
        // 执行操作
    }
};

int main() {
    ClassA objA(42);
    ClassB objB;
    objB.doSomethingWithA(objA);
    return 0;
}

3.友元函数

代码

cpp 复制代码 
class ClassA;

class ClassB {
public:
    void printValue(const ClassA& objA);
};

class ClassA {
public:
    ClassA(int value) : aValue(value) {}

    friend void ClassB::printValue(const ClassA& objA);

private:
    int aValue;
};

void ClassB::printValue(const ClassA& objA) {
    std::cout << "Value from ClassA: " << objA.aValue << std::endl;
}

int main() {
    ClassA objA(42);
    ClassB objB;

    objB.printValue(objA);

    return 0;
}

4.友元类

代码

cpp 复制代码 
class ClassA;

class ClassB {
public:
    void printValue(const ClassA& objA);

    // Declare ClassA as a friend class
    friend class ClassA;
};

class ClassA {
public:
    ClassA(int value) : aValue(value) {}

    void setValue(int value) {
        aValue = value;
    }

private:
    int aValue;
};

void ClassB::printValue(const ClassA& objA) {
    std::cout << "Value from ClassA: " << objA.aValue << std::endl;
}

int main() {
    ClassA objA(42);
    ClassB objB;

    objB.printValue(objA);

    return 0;
}

5.传递指针或引用

代码

cpp 复制代码 
#include <iostream>

class ClassA {
public:
    ClassA(int value) : aValue(value) {}

    int getValue() const {
        return aValue;
    }

private:
    int aValue;
};

class ClassB {
public:
    void printValueByPointer(const ClassA* ptrA) {
        if (ptrA) {
            std::cout << "Value from ClassA using pointer: " << ptrA->getValue() << std::endl;
        } else {
            std::cout << "Invalid pointer to ClassA." << std::endl;
        }
    }

    void printValueByReference(const ClassA& refA) {
        std::cout << "Value from ClassA using reference: " << refA.getValue() << std::endl;
    }
};

int main() {
    ClassA objA(42);
    ClassB objB;

    // Passing pointer to ClassA
    objB.printValueByPointer(&objA); // Output: Value from ClassA using pointer: 42

    // Passing reference to ClassA
    objB.printValueByReference(objA); // Output: Value from ClassA using reference: 42

    return 0;
}

6.静态成员变量

代码

cpp 复制代码 
class ClassA {
public:
    static int sharedValue;
};

class ClassB {
public:
    void printSharedValue() {
        std::cout << "Shared Value: " << ClassA::sharedValue << std::endl;
    }
};

int ClassA::sharedValue = 42;

int main() {
    ClassB objB;
    objB.printSharedValue();

    return 0;
}

7.静态成员函数

代码

cpp 复制代码 
#include <iostream>

class SharedInfo {
public:
    static int getValue() {
        return sharedValue;
    }

    static void setValue(int value) {
        sharedValue = value;
    }

private:
    static int sharedValue;
};

// Initialize the static member
int SharedInfo::sharedValue = 0;

class ClassA {
public:
    void printSharedValue() {
        std::cout << "Shared Value from ClassA: " << SharedInfo::getValue() << std::endl;
    }
};

class ClassB {
public:
    void modifySharedValue() {
        SharedInfo::setValue(100);
    }
};

int main() {
    ClassA objA;
    ClassB objB;

    objA.printSharedValue();
    objB.modifySharedValue();
    objA.printSharedValue();

    return 0;
}

8.全局变量或命名空间

代码

cpp 复制代码 
namespace MyNamespace {
    int sharedValue = 42;
}

class ClassA {
public:
    void printSharedValue() {
        std::cout << "Shared Value: " << MyNamespace::sharedValue << std::endl;
    }
};

class ClassB {
public:
    void modifySharedValue() {
        MyNamespace::sharedValue = 100;
    }
};

int main() {
    ClassA objA;
    ClassB objB;

    objA.printSharedValue();
    objB.modifySharedValue();
    objA.printSharedValue();

    return 0;
}

9.回调函数和函数指针

代码

cpp 复制代码 
#include <iostream>

// Callback function type
typedef void (*CallbackFunction)(int);

class ClassA {
public:
    ClassA(int value) : aValue(value) {}

    void performCallback(CallbackFunction callback) {
        callback(aValue);
    }

private:
    int aValue;
};

class ClassB {
public:
    static void printValue(int value) {
        std::cout << "Value from ClassA: " << value << std::endl;
    }
};

int main() {
    ClassA objA(42);
    
    // Passing callback function using function pointer
    objA.performCallback(ClassB::printValue); // Output: Value from ClassA: 42

    return 0;
}

10.观察者模式

可以使用观察者模式在C++中在两个类的实例之间传递参数。观察者模式用于在一个对象的状态发生变化时，自动通知和更新其他相关对象。以下是一个使用观察者模式的示例，并提供运行结果：

cpp 复制代码 
#include <iostream>
#include <vector>

class Observer;  // Forward declaration

class Subject {
public:
    void addObserver(Observer* observer) {
        observers.push_back(observer);
    }

    void removeObserver(Observer* observer) {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    void notify(int value) {
        for (Observer* observer : observers) {
            observer->update(value);
        }
    }

private:
    std::vector<Observer*> observers;
};

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

class ClassA : public Observer {
public:
    void attachToSubject(Subject* subject) {
        subject->addObserver(this);
    }

    void detachFromSubject(Subject* subject) {
        subject->removeObserver(this);
    }

    void update(int value) override {
        std::cout << "ClassA received update: " << value << std::endl;
    }
};

int main() {
    Subject subject;
    ClassA objA1, objA2;

    objA1.attachToSubject(&subject);
    objA2.attachToSubject(&subject);

    subject.notify(42); // Output: ClassA received update: 42 \n ClassA received update: 42

    objA1.detachFromSubject(&subject);
    subject.notify(100); // Output: ClassA received update: 100

    return 0;
}

在这个示例中，我们首先定义了一个Subject类，它维护一个观察者列表并提供添加、删除和通知观察者的功能。然后，我们定义了一个Observer类，其中包含一个抽象的update函数，用于接收主题的通知。

ClassA类继承自Observer类，实现了update函数。在main()函数中，我们创建了一个Subject对象和两个ClassA对象。然后，我们将两个ClassA对象附加到Subject对象，并调用subject.notify(42)通知观察者更新。这导致两个ClassA对象都收到了相同的更新。

接着，我们将一个ClassA对象从Subject对象分离，并再次调用subject.notify(100)。这次只有一个ClassA对象收到了更新。

运行结果将是：

ClassA received update: 42
ClassA received update: 42
ClassA received update: 100

这个例子演示了如何使用观察者模式在两个类的实例之间传递参数，其中一个类充当主题（Subject），而另一个类充当观察者（Observer）。当主题的状态发生变化时，通知所有观察者进行更新。

11.事件系统

在 C++ 中，没有内置的事件系统，但你可以模拟一个简单的事件系统来在两个类的实例之间传递参数。这可以通过函数指针、回调函数或者 C++11 中的 std::function 和 std::bind 来实现。以下是一个使用 std::function 和 std::bind 模拟事件系统的示例，并提供运行结果：

cpp 复制代码 
#include <iostream>
#include <functional>

class Event {
public:
    void subscribe(std::function<void(int)> callback) {
        subscribers.push_back(callback);
    }

    void unsubscribe(std::function<void(int)> callback) {
        subscribers.remove(callback);
    }

    void notify(int value) {
        for (auto& callback : subscribers) {
            callback(value);
        }
    }

private:
    std::list<std::function<void(int)>> subscribers;
};

class ClassA {
public:
    ClassA(Event* event) : event(event) {}

    void triggerEvent(int value) {
        event->notify(value);
    }

private:
    Event* event;
};

class ClassB {
public:
    void handleEvent(int value) {
        std::cout << "ClassB received event: " << value << std::endl;
    }
};

int main() {
    Event event;
    ClassA objA(&event);
    ClassB objB;

    // Subscribe ClassB's handleEvent to the event
    event.subscribe(std::bind(&ClassB::handleEvent, &objB, std::placeholders::_1));

    objA.triggerEvent(42); // Output: ClassB received event: 42

    // Unsubscribe ClassB's handleEvent from the event
    event.unsubscribe(std::bind(&ClassB::handleEvent, &objB, std::placeholders::_1));

    objA.triggerEvent(100);

    return 0;
}

在这个示例中，我们首先定义了一个简单的事件类 Event，它允许订阅者（函数）通过 subscribe 方法订阅事件，通过 unsubscribe 方法取消订阅，然后通过 notify 方法通知所有订阅者。接着，我们定义了两个类 ClassA 和 ClassB。ClassA 有一个触发事件的方法 triggerEvent，它会通知事件对象。ClassB 有一个处理事件的方法 handleEvent。

在 main() 函数中，我们创建了一个 Event 对象和一个 ClassA 对象。然后，我们使用 event.subscribe 方法将 ClassB::handleEvent 方法绑定到事件上，从而订阅了事件。接着，我们调用 objA.triggerEvent(42) 来触发事件，这会导致 ClassB 的 handleEvent 方法被调用。

接着，我们使用 event.unsubscribe 方法取消订阅 ClassB::handleEvent 方法，然后再次调用 objA.triggerEvent(100)，但因为已经取消了订阅，所以 ClassB 的 handleEvent 方法不会再被调用。

运行结果将是：

ClassB received event: 42

这个例子演示了如何模拟一个简单的事件系统，在两个类的实例之间传递参数。在本例中，ClassA 充当事件的触发器，ClassB 充当事件的订阅者。

12.消息传递机制

在 C++ 中，使用消息传递机制来在两个类的实例之间传递参数可以通过使用事件系统、消息队列、观察者模式等方式来实现。下面是一个使用简单的事件系统模拟消息传递机制的示例，并提供运行结果：

cpp 复制代码 
#include <iostream>
#include <functional>
#include <list>

class Message {
public:
    Message(int value) : data(value) {}

    int getData() const {
        return data;
    }

private:
    int data;
};

class EventBus {
public:
    static EventBus& getInstance() {
        static EventBus instance;
        return instance;
    }

    void publish(const Message& message) {
        for (auto& subscriber : subscribers) {
            subscriber(message);
        }
    }

    void subscribe(std::function<void(const Message&)> callback) {
        subscribers.push_back(callback);
    }

private:
    EventBus() {}

    std::list<std::function<void(const Message&)>> subscribers;
};

class ClassA {
public:
    ClassA() {
        EventBus::getInstance().subscribe(std::bind(&ClassA::handleMessage, this, std::placeholders::_1));
    }

    void sendMessage(int value) {
        Message message(value);
        EventBus::getInstance().publish(message);
    }

    void handleMessage(const Message& message) {
        std::cout << "ClassA received message with data: " << message.getData() << std::endl;
    }
};

class ClassB {
public:
    void handleMessage(const Message& message) {
        std::cout << "ClassB received message with data: " << message.getData() << std::endl;
    }
};

int main() {
    ClassA objA;
    ClassB objB;

    Message message(42);
    objA.sendMessage(message); // Output: ClassA received message with data: 42

    EventBus::getInstance().subscribe(std::bind(&ClassB::handleMessage, &objB, std::placeholders::_1));
    objA.sendMessage(100); // Output: ClassA received message with data: 100 \n ClassB received message with data: 100

    return 0;
}

在这个示例中，我们定义了一个 Message 类，表示传递的消息。然后，我们创建了一个简单的事件总线 EventBus，它允许订阅者通过 subscribe 方法订阅消息，并通过 publish 方法发布消息。ClassA 和 ClassB 分别作为消息的发送者和接收者。在 main() 函数中，我们创建了一个 ClassA 对象和一个 ClassB 对象，然后通过事件总线来传递消息。

在运行结果中，你将看到消息被成功传递并在接收者类中处理：

ClassA received message with data: 42
ClassA received message with data: 100
ClassB received message with data: 100

这个例子演示了如何使用简单的事件系统来模拟消息传递机制，在两个类的实例之间传递参数。

相关推荐
梦想科研社几秒前
【无人机设计与控制】四旋翼无人机轨迹跟踪及避障Matlab代码
开发语言·matlab·无人机
Yan-英杰几秒前
Encountered error while trying to install package.＞ lxml
开发语言·python·pandas·pip·issue
RS&4 分钟前
python学习笔记
笔记·python·学习
卡卡_R-Python5 分钟前
海洋气象编程工具-Python
开发语言·python
爱学习的真真子6 分钟前
菜鸟也能轻松上手的Java环境配置方法
java·开发语言
YRr YRr26 分钟前
在Windows上安装WSL2和Ubuntu 20.04以搭建C++开发环境的详细指南
c++·windows·ubuntu·wsl2
豆本-豆豆奶26 分钟前
23个Python在自然语言处理中的应用实例
开发语言·python·自然语言处理·编程语音
曳渔32 分钟前
Java-数据结构-二叉树-习题(三) ￣へ￣
java·开发语言·数据结构·算法·链表
Farewell_me41 分钟前
C++模拟实现list：list、list类的初始化和尾插、list的迭代器的基本实现、list的完整实现、测试、整个list类等的介绍
c++·list
你可以自己看1 小时前
python中函数式编程与高阶函数，装饰器与生成器，异常处理与日志记录以及项目实战
服务器·开发语言·python
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04软件工程从理论到实践客观题汇总(头歌第一章至第八章)05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07CCF-CSP认证考试 202406-3 文本分词 100分题解08yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10【halcon】halcon字符识别——OCR