2个试图互相访问方法的类，可以'；不能解决依赖关系 我正在学习C++和编写一个游戏。事情或多或少进展顺利。但它越大，我从依赖中得到的麻烦就越多。 如何修复这种依赖关系 class myClass_2; class myClass_1 { private: myClass_2 * myclass2; public: myClass_1() {} void setUp(myClass_2 &myclass) { myclass2 = &myclass; } void doSomething_1(){ myclass2->doSomething_2(); } }; class myClass_2 { private: myClass_1 * myclass1; public: myClass_2() {} void setUp(myClass_1 &myclass) { myclass1 = &myclass; } void doSomething_2() { myclass1->doSomething_1(); } }; int main () { myClass_1 class_1; myClass_2 class_2; class_1.setUp(class_2); class_2.setUp(class_1); return 1; }

您需要在头文件中定义类，并在cpp文件中定义成员函数

//class1.h
class myClass_2;
class myClass_1 {
    private:
        myClass_2 * myclass2;
    public:
        myClass_1();
        void setUp(myClass_2 &myclass);
        void doSomething_1();
};


//class1.cpp
#include "class1.h"
#include "class2.h"

myClass_1::myClass_1() {
}

void myClass_1::setUp(myClass_2 &myclass) {
    myclass2 = &myclass;
}

void myClass_1::doSomething_1() {
    myclass2->doSomething_2();
}

---

然后对

myClass_2

执行相同的操作。调用成员函数不需要myClass_2的成员函数定义，只需要

class2.h

中的类定义，需要在头文件中定义类，在cpp文件中定义成员函数

//class1.h
class myClass_2;
class myClass_1 {
    private:
        myClass_2 * myclass2;
    public:
        myClass_1();
        void setUp(myClass_2 &myclass);
        void doSomething_1();
};


//class1.cpp
#include "class1.h"
#include "class2.h"

myClass_1::myClass_1() {
}

void myClass_1::setUp(myClass_2 &myclass) {
    myclass2 = &myclass;
}

void myClass_1::doSomething_1() {
    myclass2->doSomething_2();
}

---

然后对

myClass_2

执行相同的操作。调用成员函数不需要myClass_2的成员函数定义，只需要在

class2.h

中找到的类定义。您需要在头文件（扩展名为

.h

和源文件（

.cpp

或

.cc

文件）中分离类定义。然后使用

#include

包含头文件以解决这些类型的问题。有关更详细的说明，请参见此链接：

您需要在头文件（扩展名为

.h

）和源文件（

.cpp

或

.cc

文件）中分离类定义。然后使用

#include

包含头文件以解决这些类型的问题。请参阅此链接以获得更详细的解释：

我希望您能准确地说出您遇到的麻烦

如果问题是它无法编译

myClass\u 1:：doSomething1（）

，因为它不知道如何调用

myclass2->doSomething2（）

，那么解决方法是将

myClass\u 1:：doSomething1（）

的定义移到

myClass\u 2

的定义下面：

class MyClass_1 {
   ...
   void doSomething_1();  // just declare it here
   ...
}

class My_Class_2 {
   ...
   void doSomething_2();
   ...
}

void MyClass_1::doSomething_1()      // now define it
{
   myclass2->doSomething_2();
}

---

我希望你能说清楚你到底遇到了什么麻烦

如果问题是它无法编译

myClass\u 1:：doSomething1（）

，因为它不知道如何调用

myclass2->doSomething2（）

，那么解决方法是将

myClass\u 1:：doSomething1（）

的定义移到

myClass\u 2

的定义下面：

class MyClass_1 {
   ...
   void doSomething_1();  // just declare it here
   ...
}

class My_Class_2 {
   ...
   void doSomething_2();
   ...
}

void MyClass_1::doSomething_1()      // now define it
{
   myclass2->doSomething_2();
}

---

将函数体移出类体。

class myClass_2;

class myClass_1 {
    private:
        myClass_2 * myclass2;
    public:
        myClass_1() {}
        void setUp(myClass_2 &myclass);
        void doSomething_1();
};

class myClass_2 {
    private:
        myClass_1 * myclass1;
    public:
        myClass_2() {}
        void setUp(myClass_1 &myclass);
        void doSomething_2();
};

void myClass_1::setUp(myClass_2 &myclass) {
    myclass2 = &myclass;
}
void myClass_1::doSomething_1(){
    myclass2->doSomething_2();
}

void myClass_2::setUp(myClass_1 &myclass) {
    myclass1 = &myclass;
}
void myClass_2::doSomething_2() {
    myclass1->doSomething_1();
}

int main () {
    myClass_1 class_1;
    myClass_2 class_2;
    class_1.setUp(class_2);
    class_2.setUp(class_1);
    return 1;
}

---

在专业的面向对象编程类中，函数声明和定义通常保存在单独的*.h和*.cpp文件中。然后，*.h文件包含在主文件中。

将函数体移到类体之外。

class myClass_2;

class myClass_1 {
    private:
        myClass_2 * myclass2;
    public:
        myClass_1() {}
        void setUp(myClass_2 &myclass);
        void doSomething_1();
};

class myClass_2 {
    private:
        myClass_1 * myclass1;
    public:
        myClass_2() {}
        void setUp(myClass_1 &myclass);
        void doSomething_2();
};

void myClass_1::setUp(myClass_2 &myclass) {
    myclass2 = &myclass;
}
void myClass_1::doSomething_1(){
    myclass2->doSomething_2();
}

void myClass_2::setUp(myClass_1 &myclass) {
    myclass1 = &myclass;
}
void myClass_2::doSomething_2() {
    myclass1->doSomething_1();
}

int main () {
    myClass_1 class_1;
    myClass_2 class_2;
    class_1.setUp(class_2);
    class_2.setUp(class_1);
    return 1;
}

---

在专业的面向对象编程类中，函数声明和定义通常保存在单独的*.h和*.cpp文件中。然后，*.h文件包含在主文件中。

我希望您在实际代码中没有真正执行类似的操作？我的意思是，如果你调用

doSomething|u 1 | 2

如果你有循环依赖，我建议你看看你的设计……我是。除此之外，我还可以如何制作与程序不同部分一起工作的主要类，以便在主题自我之间进行交互。我有地图网格课。用它管理地图和一切。它在每个地图方格中存储单位的id号。然后我有了unitfactory，它控制着与units有关的一切。单位有id。当我制作一个新单位时，我需要将id、x、y坐标传递给mapGrid，以便它可以更新地图。当我在MapGrid中说杀死x，y坐标中的所有东西时，我需要告诉UnitFactory杀死那些ID在x，y坐标中的单位为什么作为“工厂”的东西需要保持它所创建的东西的状态？当然，一旦工厂创建了该项，就要由其他人来管理该实例的生存期了？因此，从您的评论中，我收集到的是工厂创建了单元，mapgrid应该管理它的生命周期，为什么一个需要知道（或关心）另一个？我希望您在实际代码中没有真正这样做？我的意思是，如果你调用

doSomething|u 1 | 2

如果你有循环依赖，我建议你看看你的设计……我是。除此之外，我还可以如何制作与程序不同部分一起工作的主要类，以便在主题自我之间进行交互。我有地图网格课。用它管理地图和一切。它在每个地图方格中存储单位的id号。然后我有了unitfactory，它控制着与units有关的一切。单位有id。当我制作一个新单位时，我需要将id、x、y坐标传递给mapGrid，以便它可以更新地图。当我在MapGrid中说杀死x，y坐标中的所有东西时，我需要告诉UnitFactory杀死那些ID在x，y坐标中的单位为什么作为“工厂”的东西需要保持它所创建的东西的状态？当然，一旦工厂创建了该项，就要由其他人来管理该实例的生存期了？所以从你的评论中，我收集到的是工厂创建了这个单元，mapgrid应该管理它的生命周期，为什么一个需要知道（或关心）另一个呢？像这样，我会有很多.cpp文件。我将如何让编译器理解它应该以什么顺序将它们放在一起？由于每个单独的文件只有标题，编译顺序无关紧要。头文件基本上是说“一个类存在并且看起来像这样”，cpp文件提供了这些类的实际代码。链接器处理其余部分，所以我基本上可以这样编译。“g++main.cpp something.cpp/something/something.cpp-o myProgram”。如果是这样的话，字符串不会变得庞大且难以管理吗？

g++-Wall-c-o main.o main.cpp

编译一个文件。像那样编译它们，然后链接到

g++-omyappmain.ofile1.ofile2.o

。也要考虑学习如何编写一个Maple文件，这样我就有很多.CPP文件了。我将如何让编译器理解它应该以什么顺序将它们放在一起？由于每个单独的文件只有标题，编译顺序无关紧要。头文件基本上说是“一个类存在并且