[已解决]为什么类外定义可以通过而类内却报错呢？

叶落了

#include<iostream>
using namespace std;
#include<string>

//类做友元

class Building
{
        friend goodGay;
public:

        Building()
        {
                m_sittingRoom = "客厅";
                m_bedRoom = "卧室";

        }

public:

        string m_sittingRoom;

private:

        string m_bedRoom;
};

class goodGay
{
public:
        goodGay()
        {
                building = new Building;//难道是因为虽然声明了但运行到这里的时候还是没有具体的，放在上面试试
        }

        Building * building;

        void visit()
        {
                   cout << "好基友正在访问你的 " << building->m_sittingRoom << endl;
               cout << "好基友正在访问你的 " << building->m_bedRoom << endl;
        }

        ~goodGay()
        {
                if ( building != NULL)
                {
                        delete(building);
                        building = NULL;
                }
        }
};



//类外完善函数
//void goodGay::visit()
//{
//        cout << "好基友正在访问你的 " << building->m_sittingRoom << endl;
//        cout << "好基友正在访问你的 " << building->m_bedRoom << endl;
//}
//
//goodGay::goodGay()
//{
//        //创造建筑物对象
//        building = new Building;
//}
//
//Building::Building()
//{
//        m_sittingRoom = "客厅";
//        m_bedRoom = "卧室";
//}
//
void test01()
{
        goodGay gg;
        gg.visit();
}

int main()
{
        test01();

        return 0;
}

最佳答案

月排行榜 / 总排行榜

FishC

2024-1-4 22:37:26

你好！这个问题是因为在类`goodGay`中访问了类`Building`的私有成员`m_bedRoom`，而在类`Building`中定义了一个友元类`goodGay`，允许`goodGay`类访问`Building`的私有成员。但是你在定义`goodGay`类对象的同时，没有将其声明为友元类，所以导致编译错误。

解决办法是在`Building`类的定义前面加上`class goodGay;`的前置声明，这样就可以通过编译了。

完整代码如下：

1. #include<iostream>
   
2. using namespace std;
   
3. 
   
4. // 前置声明
   
5. class goodGay;
   
6. 
   
7. // 类做友元
   
8. class Building
   
9. {
   
10.         friend goodGay;
    
11. public:
    
12.         Building()
    
13.         {
    
14.                 m_sittingRoom = "客厅";
    
15.                 m_bedRoom = "卧室";
    
16.         }
    
17. 
    
18. public:
    
19.         string m_sittingRoom;
    
20. 
    
21. private:
    
22.         string m_bedRoom;
    
23. };
    
24. 
    
25. class goodGay
    
26. {
    
27. public:
    
28.         goodGay()
    
29.         {
    
30.                 building = new Building;
    
31.         }
    
32. 
    
33.         Building* building;
    
34.        
    
35.         void visit()
    
36.         {
    
37.                 cout << "访问到了：" << building->m_sittingRoom << endl;
    
38.                 cout << "访问到了：" << building->m_bedRoom << endl;
    
39.         }
    
40. };
    
41. 
    
42. int main()
    
43. {
    
44.         goodGay gg;
    
45.         gg.visit();
    
46. 
    
47.         return 0;
    
48. }

复制代码

现在你就可以在`goodGay`的`visit`函数中正常访问`Building`类的私有成员了。希望对你有帮助！如果还有其他问题，请随时提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

跳转到最佳答案楼层

FishC

类内部访问类外部定义的成员需要满足以下两个条件：
1. 成员函数必须在类外部定义之后进行声明。
2. 成员函数的定义必须包含类外部定义的成员。

在你的代码中，goodGay类内的成员函数visit()没有按照以上条件进行定义，因此编译器无法找到类外部定义的Building类。

正确的代码应该是这样的：

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. class Building;  // 声明Building类，告诉编译器该类存在
   
5. 
   
6. class goodGay
   
7. {
   
8. public:
   
9.     goodGay();  // goodGay类构造函数
   
10.     void visit();  // 成员函数visit的声明
    
11. 
    
12. private:
    
13.     Building* building;  // 声明Building类型的指针
    
14. };
    
15. 
    
16. class Building
    
17. {
    
18.     friend class goodGay;  // Building类声明goodGay为友元类
    
19. public:
    
20.     Building()
    
21.     {
    
22.         m_sittingRoom = "客厅";
    
23.         m_bedRoom = "卧室";
    
24.     }
    
25. 
    
26. private:
    
27.     string m_sittingRoom;
    
28.     string m_bedRoom;
    
29. };
    
30. 
    
31. goodGay::goodGay()
    
32. {
    
33.     building = new Building;  // 在goodGay类构造函数中创建Building对象
    
34. }
    
35. 
    
36. void goodGay::visit()
    
37. {
    
38.     cout << "我正在访问" << building->m_sittingRoom << "和" << building->m_bedRoom << endl;
    
39. }

复制代码

在这里，我们首先在goodGay类的声明之前声明了Building类的存在，然后在goodGay类的成员函数visit()之前进行了声明。在goodGay类的构造函数中，我们通过new运算符创建了一个Building对象，并将其赋给goodGay类的building成员指针。最后，在visit()函数中，我们可以通过building指针访问Building类的成员。

这样修改之后，你就可以顺利通过编译，并且在goodGay类的visit()函数中访问到Building类的成员了。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

你好！这个问题是因为在类`goodGay`中访问了类`Building`的私有成员`m_bedRoom`，而在类`Building`中定义了一个友元类`goodGay`，允许`goodGay`类访问`Building`的私有成员。但是你在定义`goodGay`类对象的同时，没有将其声明为友元类，所以导致编译错误。

解决办法是在`Building`类的定义前面加上`class goodGay;`的前置声明，这样就可以通过编译了。

完整代码如下：

1. #include<iostream>
   
2. using namespace std;
   
3. 
   
4. // 前置声明
   
5. class goodGay;
   
6. 
   
7. // 类做友元
   
8. class Building
   
9. {
   
10.         friend goodGay;
    
11. public:
    
12.         Building()
    
13.         {
    
14.                 m_sittingRoom = "客厅";
    
15.                 m_bedRoom = "卧室";
    
16.         }
    
17. 
    
18. public:
    
19.         string m_sittingRoom;
    
20. 
    
21. private:
    
22.         string m_bedRoom;
    
23. };
    
24. 
    
25. class goodGay
    
26. {
    
27. public:
    
28.         goodGay()
    
29.         {
    
30.                 building = new Building;
    
31.         }
    
32. 
    
33.         Building* building;
    
34.        
    
35.         void visit()
    
36.         {
    
37.                 cout << "访问到了：" << building->m_sittingRoom << endl;
    
38.                 cout << "访问到了：" << building->m_bedRoom << endl;
    
39.         }
    
40. };
    
41. 
    
42. int main()
    
43. {
    
44.         goodGay gg;
    
45.         gg.visit();
    
46. 
    
47.         return 0;
    
48. }

复制代码

现在你就可以在`goodGay`的`visit`函数中正常访问`Building`类的私有成员了。希望对你有帮助！如果还有其他问题，请随时提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。