[已解决]友元 ，在类Building里面已经声明多了，visit1函数是其友元，还是无法访问私有

猪猪虾

还是无法访问私有成员

1. //全局函数做友元
   
2. 
   
3. #include <stdio.h>
   
4. #include<iostream>
   
5. #include<cstring>
   
6. #include<cstdio>
   
7. 
   
8. using namespace std;
   
9. 
   
10. class Building
    
11. {
    
12.         friend void GoodGay::visit1();
    
13. public:
    
14.         Building()
    
15.         {
    
16.                 m_sittingRoom = "客厅";
    
17.                 m_bedRoom = "卧室";
    
18.         }
    
19. 
    
20.         string m_sittingRoom;
    
21. 
    
22. private:
    
23.         string m_bedRoom;
    
24. };
    
25. 
    
26. 
    
27. class GoodGay
    
28. {
    
29. public:
    
30.         Building* building;
    
31.         GoodGay()
    
32.         {
    
33.                 building = new Building;  //new什么就返回什么，创建了一个Building指针
    
34.         }
    
35. 
    
36.         void visit1()  //让这个函数可以访问building的私有成员
    
37.         {
    
38.                 cout << "visit1 is visting :" << building->m_sittingRoom << endl;
    
39.                 cout << "visit1 is visting :" << building->m_bedRoom << endl;
    
40.         }
    
41. 
    
42.         void vist2()//让这个函数不可以访问building的私有成员
    
43.         {
    
44.                 cout << "visit2 is visting :" << building->m_sittingRoom << endl;
    
45.         }
    
46. };
    
47. 
    
48. 
    
49. int main()
    
50. {
    
51.         GoodGay gay;
    
52.         gay.visit1();
    
53.         gay.vist2();
    
54.         return 0;
    
55. }

复制代码

最佳答案

月排行榜 / 总排行榜

傻眼貓咪

2022-1-19 21:37:10

猪猪虾 发表于 2022-1-19 21:20
你这是在类外面实现成员函数，我是在类内。和声明与否没关系把

你注意你的 第 12 行 代码，系统根本不知道 GoodGay 从哪里来，因为还没有声明，直到第 31 行才出现，不能先吃饭才煮饭啊大哥。

你的问题如同：

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. int A(int a, int b){
   
5.     return B(a, b); // 系统根本不懂 B() 是什么
   
6. }
   
7. 
   
8. int B(int a, int b){ // 这里才开始声明定义 B()
   
9.     return a*b;
   
10. }
    
11. 
    
12. int main()
    
13. {
    
14.     return 0;
    
15. }

复制代码

跳转到最佳答案楼层

傻眼貓咪

你的思路基本没有问题，但是声明和定义循序有问题，你要确定哪里一个优先声明和定义：（注：这里用提前声明 Forward declaration 方法，不然报错）

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. class Building; // 注意这里，提前声明 Forward declaration
   
5. 
   
6. class GoodGay // 注意这里
   
7. {
   
8. public:
   
9.     void visit1(); // 注意这里，提前声明 Forward declaration
   
10.     void vist2();  // 注意这里，提前声明 Forward declaration
    
11.     GoodGay();     // 构造函数声明
    
12.     ~GoodGay();    // 析构函数声明
    
13.     Building* building;
    
14. };
    
15. 
    
16. class Building // 注意这里
    
17. {
    
18.     public:
    
19.         Building()
    
20.         {
    
21.             m_sittingRoom = "客厅";
    
22.             m_bedRoom = "卧室";
    
23.         }
    
24.         string m_sittingRoom;
    
25.         friend void GoodGay::visit1();
    
26.     private:
    
27.         string m_bedRoom;
    
28. };
    
29. 
    
30. GoodGay::GoodGay() // 注意这里，必须在定义 class Building 之后才能定义
    
31. {
    
32.     building = new Building;
    
33. }
    
34. 
    
35. GoodGay::~GoodGay()
    
36. {
    
37.     delete building; // 凡是有 new，必然要有 delete
    
38. }
    
39. 
    
40. void GoodGay::visit1() // 注意这里，必须在定义 class Building 之后才能定义
    
41. {
    
42.     cout << "visit1 is visting :" << building->m_sittingRoom << endl;
    
43.     cout << "visit1 is visting :" << building->m_bedRoom << endl;
    
44. }
    
45. 
    
46. void GoodGay::vist2() // 注意这里，必须在定义 class Building 之后才能定义
    
47. {
    
48.     cout << "visit2 is visting :" << building->m_sittingRoom << endl;
    
49. }
    
50. 
    
51. int main(){
    
52.     GoodGay gay;
    
53.     gay.visit1();
    
54.     gay.vist2();
    
55.     return 0;
    
56. }

复制代码

猪猪虾

傻眼貓咪 发表于 2022-1-17 20:58
你的思路基本没有问题，但是声明和定义循序有问题，你要确定哪里一个优先声明和定义：（注：这里用提前声明 ...

你这是在类外面实现成员函数，我是在类内。和声明与否没关系把

傻眼貓咪

猪猪虾 发表于 2022-1-19 21:20
你这是在类外面实现成员函数，我是在类内。和声明与否没关系把

大哥，写代码很辛苦，尤其是特长代码，希望你认真看清楚。

我拿其中一个例子，你的 GoodGay() 是 GoodGay 的构造函数，在 GoodGay 里面声明了，但是必须 Building 之后才能定义。
你的代码牵涉很多声明和定义顺序。

如果用你的代码执行，报错已经说明一切！

傻眼貓咪

猪猪虾 发表于 2022-1-19 21:20
你这是在类外面实现成员函数，我是在类内。和声明与否没关系把

你注意你的 第 12 行 代码，系统根本不知道 GoodGay 从哪里来，因为还没有声明，直到第 31 行才出现，不能先吃饭才煮饭啊大哥。

你的问题如同：

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. int A(int a, int b){
   
5.     return B(a, b); // 系统根本不懂 B() 是什么
   
6. }
   
7. 
   
8. int B(int a, int b){ // 这里才开始声明定义 B()
   
9.     return a*b;
   
10. }
    
11. 
    
12. int main()
    
13. {
    
14.     return 0;
    
15. }

复制代码