C++多类间的调用解决方案

于 2025-04-23 15:15:14 发布
阅读量595 收藏 13
点赞数 21
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beyondmadman/article/details/147455256
版权

方法 1：前向声明+指针

  1. 使用前向声明：在类的头文件中前向声明另一个类，避免直接包含头文件。

  2. 使用指针或引用：在类的成员变量或方法参数中使用对方类的指针或引用，因为前向声明仅支持指针/引用类型。

  3. 分离头文件与实现：在源文件（.cpp）中包含对方的头文件，确保方法实现时能访问完整定义。

示例代码：
A.h（类A的头文件）
#ifndef A_H
#define A_H

// 前向声明类B
class B;

class A {
private:
    B* b_ptr; // 使用指针
public:
    A(B* b);
    void methodA();
    void setB(B* b);
};

#endif
B.h（类B的头文件）
#ifndef B_H
#define B_H

// 前向声明类A
class A;

class B {
private:
    A* a_ptr; // 使用指针
public:
    B(A* a);
    void methodB();
    void setA(A* a);
};

#endif
A.cpp（类A的实现）
#include "A.h"
#include "B.h" // 包含B的头文件以访问完整定义

A::A(B* b) : b_ptr(b) {}

void A::methodA() {
    // 调用B的方法
    b_ptr->methodB();
}

void A::setB(B* b) {
    b_ptr = b;
}
B.cpp（类B的实现）
#include "B.h"
#include "A.h" // 包含A的头文件以访问完整定义

B::B(A* a) : a_ptr(a) {}

void B::methodB() {
    // 调用A的方法
    a_ptr->methodA();
}

void B::setA(A* a) {
    a_ptr = a;
}
main.cpp（使用示例）
#include "A.h"
#include "B.h"

int main() {
    B b(nullptr);
    A a(&b);
    b.setA(&a);

    a.methodA(); // 触发相互调用
    return 0;
}

关键点：

  • 避免头文件循环包含：通过前向声明替代直接包含头文件。

  • 指针/引用替代对象：成员变量或参数中使用指针/引用，避免编译器需要完整定义。

  • 实现分离：在源文件中包含必要头文件，确保方法实现时可访问类成员。

注意事项：

  • 递归调用风险：确保逻辑正确，避免无限递归（如a.methodA()调用b.methodB()，后者又调用a.methodA()）。

  • 内存管理：若使用原始指针，需注意对象生命周期，避免悬挂指针。建议使用智能指针（如std::shared_ptr）增强安全性。

方法 2：使用接口（抽象基类）

通过定义接口类（抽象基类）解耦具体实现，让相互调用的类依赖接口而非具体类型。

示例代码：
// IInterface.h
#pragma once
class IInterface {
public:
    virtual void doSomething() = 0;
    virtual ~IInterface() = default;
};

// A.h
#pragma once
#include "IInterface.h"
class A : public IInterface {
public:
    void doSomething() override;
    void setDependency(IInterface* dep);
private:
    IInterface* dependency = nullptr;
};

// B.h
#pragma once
#include "IInterface.h"
class B : public IInterface {
public:
    void doSomething() override;
    void setDependency(IInterface* dep);
private:
    IInterface* dependency = nullptr;
};

// A.cpp
#include "A.h"
void A::doSomething() {
    if (dependency) dependency->doSomething();
}
void A::setDependency(IInterface* dep) { dependency = dep; }

// B.cpp
#include "B.h"
void B::doSomething() {
    if (dependency) dependency->doSomething();
}
void B::setDependency(IInterface* dep) { dependency = dep; }

// main.cpp
#include "A.h"
#include "B.h"
int main() {
    A a;
    B b;
    a.setDependency(&b);
    b.setDependency(&a);
    a.doSomething(); // 通过接口调用
    return 0;
}

优点：

  • 完全解耦具体实现，符合面向接口编程原则。

  • 支持多态和动态替换依赖对象。

缺点：

  • 需要定义额外的接口类，代码量增加。

方法 3：使用中介者模式（Mediator Pattern）

通过引入一个中间协调类（Mediator），让原本直接交互的类通过中介者通信。

示例代码：
// Mediator.h
#pragma once
#include <memory>
class A;
class B;

class Mediator {
public:
    virtual void notifyA() = 0;
    virtual void notifyB() = 0;
    virtual ~Mediator() = default;
};

// A.h
#pragma once
#include "Mediator.h"
class A {
public:
    A(Mediator* mediator) : mediator_(mediator) {}
    void callB() { mediator_->notifyB(); }
private:
    Mediator* mediator_;
};

// B.h
#pragma once
#include "Mediator.h"
class B {
public:
    B(Mediator* mediator) : mediator_(mediator) {}
    void callA() { mediator_->notifyA(); }
private:
    Mediator* mediator_;
};

// ConcreteMediator.cpp
#include "Mediator.h"
#include "A.h"
#include "B.h"
class ConcreteMediator : public Mediator {
public:
    ConcreteMediator(A* a, B* b) : a_(a), b_(b) {}
    void notifyA() override { /* 处理 A 的通知 */ }
    void notifyB() override { /* 处理 B 的通知 */ }
private:
    A* a_;
    B* b_;
};

// main.cpp
int main() {
    ConcreteMediator mediator;
    A a(&mediator);
    B b(&mediator);
    a.callB(); // 通过中介者调用
    return 0;
}

优点：

  • 集中控制逻辑，减少类间的直接依赖。

  • 扩展性强，新增交互逻辑只需修改中介者。

缺点：

  • 需要额外设计中介者类，可能引入复杂度。

方法 4：依赖注入（Dependency Injection）

通过外部容器管理依赖关系，动态注入对象实例，避免硬编码依赖。

示例代码（使用简单的手动依赖注入）：
// ServiceA.h
#pragma once
class ServiceB;
class ServiceA {
public:
    ServiceA(ServiceB* b) : b_(b) {}
    void doSomething();
private:
    ServiceB* b_;
};

// ServiceB.h
#pragma once
class ServiceA;
class ServiceB {
public:
    ServiceB(ServiceA* a) : a_(a) {}
    void doSomething();
private:
    ServiceA* a_;
};

// main.cpp
#include "ServiceA.h"
#include "ServiceB.h"
int main() {
    ServiceA* a = nullptr;
    ServiceB* b = nullptr;
    
    // 手动创建并注入依赖
    a = new ServiceA(b);
    b = new ServiceB(a);
    
    a->doSomething();
    delete a;
    delete b;
    return 0;
}

优点：

  • 依赖关系清晰，易于单元测试（通过 Mock 对象）。

  • 符合单一职责原则。

缺点：

  • 需要手动管理依赖，复杂项目可借助框架（如 Google Fruit、Boost.DI）。

方法 5：模板方法（Template-based）

利用模板在编译时解决依赖，适用于类型已知的场景。

示例代码：
// A.h
#pragma once
template <typename T>
class A {
public:
    void callDependency(T& dep) { dep.method(); }
};

// B.h
#pragma once
template <typename T>
class B {
public:
    void callDependency(T& dep) { dep.method(); }
};

// main.cpp
#include "A.h"
#include "B.h"
int main() {
    A<B<int>> a;
    B<A<int>> b;
    // 使用时需确保类型兼容
    return 0;
}

优点：

  • 编译时解决依赖，无运行时开销。

  • 灵活性强，适合泛型编程。

缺点：

  • 模板代码可能难以调试。

  • 类型约束需明确，否则易导致编译错误。

方法 6：观察者模式（Observer Pattern）

适用于事件驱动的场景，通过订阅-通知机制实现间接调用。

示例代码：
// Observer.h
#pragma once
#include <functional>
class Observer {
public:
    virtual void onEvent() = 0;
    virtual ~Observer() = default;
};

// Subject.h
#pragma once
#include <vector>
#include "Observer.h"
class Subject {
public:
    void addObserver(Observer* obs) { observers_.push_back(obs); }
    void notify() { for (auto obs : observers_) obs->onEvent(); }
private:
    std::vector<Observer*> observers_;
};

// A.h
#pragma once
#include "Observer.h"
class A : public Observer {
public:
    void onEvent() override { /* 处理事件 */ }
};

// B.h
#pragma once
#include "Observer.h"
class B : public Observer {
public:
    void onEvent() override { /* 处理事件 */ }
};

优点：

  • 松耦合，动态管理依赖关系。

  • 支持一对多通知。

缺点：

  • 需要定义事件机制，适合异步场景。

总结

方法适用场景优点缺点
前向声明+指针简单相互调用直接、无需额外设计需管理指针，可能循环调用
接口抽象需要多态或替换实现高度解耦，符合 OCP 原则需定义接口类
中介者模式复杂交互逻辑集中控制，减少直接依赖引入额外中介者类
依赖注入需要灵活管理依赖易于测试，依赖清晰手动注入繁琐，框架有学习成本
模板方法编译时确定类型零运行时开销，泛型友好模板复杂度高，调试困难
观察者模式事件驱动或异步场景松耦合，支持动态通知需事件机制，可能过度设计

选择方法时，需权衡 代码复杂度、维护成本 和 具体需求。对于简单项目，前向声明+指针足够；对于大型项目，接口抽象或依赖注入更合适。

beyondmadman
关注
C++两个类相互调用
yuanchunsi的博客
12-06 4431
C++两个类相互调用
C++中两个类互相引用的解决方法
西青年·部落格
11-17 1万+
一、问题描述 现在有两个类A和B需要定义，定义A的时候需要用到B，定义B的时候需要用到A。 二、分析 A和B的定义和调用都放在一个文件中肯定是不可以的，这样就会造成两个循环调用的死循环。 根本原因是：定义A的时候，A的里面有B，所以就需要去查看B的占空间大小，但是查看的时候又发现需要知道A的占空间大小，造成死循环。 解决方法1： （1）写两个头文件A.h和B.h分别用于声明类A和B；
C++ 类之间的互相调用
weixin_30663471的博客
06-08 483
这几天做C++11的线程池时遇到了一个问题，就是类A想要调用类B的方法，而类B也想调用类A的方法 这里为了简化起见，我用更容易理解的观察者模式向大家展开陈述 观察者模式：在对象之间定义一对多的依赖，这样一来，当一个对象改变状态时，依赖它的对象都会收到通知，并自动更新 观察者模式中有一个subject和observer observer向subject注册成为一个观察者 当sub...
C++ 两个类互相调用
ACodeLife的博客
11-22 8699
总所周知，我们想要调用一个类，一定要添加他的头文件。例如，class A 调用class B， 在class A 头文件中，这样子就可以了。如： A.h #ifndef A_H #define A_H #include "B.h" class A { public: A(); B b; }; #endif 但是，如果我想class A 调用class B ， class B 调...
C++两个类相互调用实现
于大博
09-10 3252
两个类A和B实现互相调用彼此的方法，如果采用彼此包含对方头文件的方式会出现循环引用，所以采用了类的前置声明的方式: 1.class A采用前置声明的方式声明class B 2.在ClassB的头文件中包含class A 的头文件 3.在class A中只能声明class B类型的指针或者引用 具体代码如下： A.h #pragma once class B; class A { ...
C#调用C++DLL传递结构体数组的终极解决方案
12-31
C#调用C++DLL传递结构体数组的终极解决方案 在项目开发时，要调用C++封装的DLL，普通的类型C#上一般都对应，只要用DllImport传入从DLL中引入函数就可以了。但是当传递的是结构体、结构体数组或者结构体指针的时候，...
C++调用Go方法的字符串传递问题及解决方案
01-19
摘要：C++调用Go方法时...经过一段时间的分析和验证，终于理解问题产生的原因并给出解决方案，现分享如下。 背景知识 Go有自己的内存回收GC机制，通过make等申请的内存不需要手动释放。 C++中为std::string变量赋值
PaddleX C++ DLL导出工具：支持C#调用的AI模型分类、分割、检测一体化解决方案
最新发布
05-09
内容概要：本文详细介绍了如何将PaddleX的C++模型导出为DLL并支持C#调用，涵盖了图像分类、分割和检测三大AI模型的功能。文章首先展示了C++侧的核心封装逻辑，包括初始化、预测和释放模型的接口设计。接着，重点讲解...
C语言工程调用C++库解决方案
whscheetah的博客
04-18 2027
本文为C语言工程调用C++库的解决方案。应用场景： 需要C++程序编译成的库提供函数接口，来解决C语言工程的需求。人的出场顺序真的很重要，很多人如果换一个时间认识，换一个时间共处，一切都将是不一样的场景，不一样的结局。所以，人生有无限种可能，我的人生，是现在这一种。------ 大家好啊 我是 暮冬Z羡慕。
C++两个类互相调用的方法(类-＞通用类型转换)
rocklee的专栏
06-29 1229
最近修改一个C++项目,A/B两个类需要互相调用,但是.h头文件互相include是不被允许的,所以只能将其中一个类的.cpp里面引用另一个类的头文件的做法. 所以这涉及到类->通用类型->类的转换,这里常用的通用类型为std::uintptr_t , 类转uintptr_t reinterpret_caststd::uintptr_t(&yourclassIns) uintptr_t转类 YourClass yourclassIns = (YourClass)reinterpret_
C++ 包含类两个类互相调用彼此的类成员变量和方法
09-13
C++，C 包含类两个类互相调用彼此的类成员变量和方法，里面介绍了如何在头文件中创建相互的类对象，简单易懂
c++ 类的互相调用的方法
12-25
c++ 类的互相调用的方法,是今天弄明白的,这里提供例子和说明给大家参考,从而告诉大家C++中类与类之间的关系,是不能烂用乱用的.希望能给大家启发.
C++两个类互相调用彼此的方法
weixin_41823188的博客
09-26 1939
今天在学习c++primer 第七章的时候，做练习题出现了个问题，如下： X.h文件代码： #pragma once #include"Y.h" class X { public: private: Y* y = nullptr; }; Y.h文件代码： #pragma once #include"X.h" class Y { public: private: X x; }; main函数： #include"X.h" #include"Y.h" int main() { X x;
C++类之间相互调用
zoutaofen的博客
01-04 2151
简单快速便于理解，每个类只有一个实例对象，实例个数少时使用方便，推荐使用此方法。类个数多，每个类要创建多个实例对象，使用容易出错，不建议使用此方法。类个数多，每个类要创建多个实例对象快速方便，建议使用此方法。相对复杂，初次使用理解困难。
C++ 两个包含类互相调用彼此的类成员变量和方法
qq_27278957的博客
09-13 1万+
C++ 两个包含类互相调用彼此的类成员变量和方法
C++中两个类中互相引用
jiange_zh的博客
10-02 2737
有时候，我们会有两个类需要互相引用的场景，由于两个类的定义是有顺序的，因此两个类相互引用，不管哪个类在前面，都会出现有一个类未定义的情况。这时可以通过类的前置声明来提前告诉编译器，所要引用的是个类，但由于此时后面的那个类还没有定义，因此无法给对象分配确定的内存空间，故只能使用类指针而不能是类实体。// A.h #include "B.h" class A { public: A(B* pB)
C++ 两个类互相引用
在线笔记
10-08 2774
编译出错，未找到B的定义，在使用一个类时，必须找到类的定义，或者使用如下三种方法 1. 使用指针 B*b; 2. 使用引用B& b; 3. 类分成头文件，互相包含 class A {   B b; } class B
【C++】两个类的相互引用
热门推荐
Yngz_Miao的博客
01-03 2万+
有时候在设计数据结构的时候，可能会遇到两个类需要相互引用的情形。比如类A有类型为B的成员，而类B又有类型为A的成员。 那么这种情形下，两个类的设计上需要注意什么呢？ 本文实例源码github地址：https://github.com/yngzMiao/yngzmiao-blogs/tree/master/2021Q1/20210103。 同一文件 尝试方案 将A和B的定义都放在一个文件中，例如： #include <iostream> class A { public: A()
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值