目录

ClassA.h

 ClassA.cpp

ClassB.h

ClassB.cpp

---

error: C2143: 语法错误: 缺少“；”(在“*”的前面)

当两个类需要相互访问对方的成员或方法时，通常意味着它们之间存在某种依赖关系。这种依赖关系可能源于类的设计或功能需求。以下是一个简单的例子，展示了当两个类需要相互访问对方成员或方法时，如何使用包含对方头文件的方式来解决循环包含的问题。

假设我们有两个类：ClassA 和 ClassB。ClassA 有一个成员变量 bPtr，它是 ClassB 的指针，并且 ClassA 有一个成员函数 doSomethingWithB()，该函数需要访问 ClassB 的某个成员或方法。同时，ClassB 也有一个成员变量 aPtr，它是 ClassA 的指针，并且 ClassB 有一个成员函数 doSomethingWithA()，该函数需要访问 ClassA 的某个成员或方法。

ClassA.h

#ifndef CLASSA_H
#define CLASSA_H
#include <iostream>
using namespace std;
// 前向声明 ClassB，因为 ClassA 只需要一个指向 ClassB 的指针
class ClassB;

class ClassA {
public:
    ClassA();
    ~ClassA();

    // 成员函数需要访问 ClassB 的成员或方法，因此需要包含 ClassB.h
    void doSomethingWithB();
    void funA();
    // 指向 ClassB 的指针
    ClassB* bPtr;
};

// 注意：由于 doSomethingWithB() 需要访问 ClassB 的成员，我们将在 ClassA.cpp 中包含 ClassB.h
#endif // CLASSA_H

 ClassA.cpp

#include "ClassA.h"
#include "ClassB.h" // 包含 ClassB.h 以使用 ClassB 的成员或方法

ClassA::ClassA() {
    // 初始化代码...
}

ClassA::~ClassA() {
    // 清理代码...
}

void ClassA::doSomethingWithB() {
    // 假设 ClassB 有一个名为 methodOfB() 的成员函数
    bPtr->funB(); // 访问 ClassB 的成员或方法
}

void ClassA::funA()
{
    cout<<"ClassA::funA()"<<endl;
}

ClassB.h

#ifndef CLASSB_H
#define CLASSB_H
#include <iostream>
using namespace std;
// 前向声明 ClassA，因为 ClassB 只需要一个指向 ClassA 的指针
class ClassA;

class ClassB {
public:
    ClassB();
    ~ClassB();

    // 成员函数需要访问 ClassA 的成员或方法，因此需要包含 ClassA.h
    void doSomethingWithA();
    void funB();
    // 指向 ClassA 的指针
    ClassA* aPtr;
};

// 注意：由于 doSomethingWithA() 需要访问 ClassA 的成员，我们将在 ClassB.cpp 中包含 ClassA.h
#endif // CLASSB_H

ClassB.cpp

#include "ClassB.h"
#include "ClassA.h" // 包含 ClassA.h 以使用 ClassA 的成员或方法

ClassB::ClassB() {
    // 初始化代码...
}

ClassB::~ClassB() {
    // 清理代码...
}

void ClassB::doSomethingWithA() {
    // 假设 ClassA 有一个名为 methodOfA() 的成员函数
    aPtr->funA(); // 访问 ClassA 的成员或方法
}

void ClassB::funB()
{
    cout<<"ClassB::funB()"<<endl;
}

在这个例子中，我们使用了前向声明来告诉编译器ClassA和ClassB的存在，但在需要访问对方成员或方法的实现文件中（.cpp文件），我们包含了对方的头文件。这样，我们就可以避免循环包含问题，同时又能保持类之间的依赖关系。