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

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

相关推荐
龙鸣丿几秒前
Linux基础学习笔记
linux·笔记·学习
一点媛艺1 小时前
Kotlin函数由易到难
开发语言·python·kotlin
姑苏风1 小时前
《Kotlin实战》-附录
android·开发语言·kotlin
奋斗的小花生2 小时前
c++ 多态性
开发语言·c++
魔道不误砍柴功2 小时前
Java 中如何巧妙应用 Function 让方法复用性更强
java·开发语言·python
Nu11PointerException2 小时前
JAVA笔记 | ResponseBodyEmitter等异步流式接口快速学习
笔记·学习
闲晨2 小时前
C++ 继承：代码传承的魔法棒，开启奇幻编程之旅
java·c语言·开发语言·c++·经验分享
老猿讲编程3 小时前
一个例子来说明Ada语言的实时性支持
开发语言·ada
UestcXiye3 小时前
《TCP/IP网络编程》学习笔记 | Chapter 3：地址族与数据序列
c++·计算机网络·ip·tcp
Chrikk3 小时前
Go-性能调优实战案例
开发语言·后端·golang
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【TC3xx芯片】TC3xx芯片电源管理系统PMS详解05基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测06【经验分享】Ubuntu22.04安装微信(linux官方版)07Macbook pro M1 安装Ubuntu教程08RAG 实践- Ollama+RagFlow 部署本地知识库09Windows10安装PCL1.14.0及点云配准10文件或文件夹名称中有空格如何批量去除