private/protected/public

private调用范围：类内，友元函数

protected调用范围：类内，子类（派生类），友元函数

public调用范围：类内，类外

1.证明private调用范围：类内，友元函数可调用，而不可在类外和子类(派生类)调用

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 class A
 6 {
 7 public:
 8     A():x(0){}
 9     A(int x):x(x){}
10     friend A operator+(const A &left ,const A &right);
11     void display1()
12     {
13         cout<< "x=" << x << endl;//可正常输出则证明可在类内调用
14     }
15 private://private访问属性
16     int x;
17 };
18 A operator+(const A &left ,const A &right)//友元函数
19 {
20     A temp;
21     temp.x = left.x + right.x;
22     return temp;
23 }
24 class B:public A
25 {
26 public:
27     void show_B()
28     {
29         cout << "子类x=" << a3.x << endl;
30     }
31 private:
32     int y;
33 };
34 
35 
36 int main()
37 {
38     A a1(1);
39     A a2(2);
40     A a3;
41     a3 = a1 + a2;//运用了友元函数
42     a3.display1();//若能够输出a3=3就证明private在友元函数中可调用
43     B b1;
44     b1.show_B();//若能够输出子类x=3就可证明private在子类可调用
45     cout << "类外x=" << a3.x << endl;//若能够输出类外x=3就可证明private在类外可调用
46     return 0;
47 }

调试后

11行正常输出

42行显示了a3=3

44行显示了error：'int A::x' is private within this context（“int A:：x”在此上下文中是私有的）

45行显示了error：'int A::x' is private within this context（“int A:：x”在此上下文中是私有的）

由此可知，结论正确

2.证明protected调用范围：类内，子类（派生类），友元函数可调用，而不可在类外调用

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 class A
 6 {
 7 public:
 8     A():x(0){}
 9     A(int x):x(x){}
10     friend A operator+(const A &left ,const A &right);
11     void display1()
12     {
13         cout<< "x=" << x << endl;//可正常输出则证明可在类内调用
14     }
15 protected://private访问属性
16     int x;
17 };
18 A operator+(const A &left ,const A &right)//友元函数
19 {
20     A temp;
21     temp.x = left.x + right.x;
22     return temp;
23 }
24 class B:public A
25 {
26 public:
27     void show_B()
28     {
29         cout << "子类x=" << x << endl;
30     }
31 private:
32     int y;
33 };
34 
35 
36 int main()
37 {
38     A a1(1);
39     A a2(2);
40     A a3;
41     a3 = a1 + a2;//运用了友元函数
42     a3.display1();//若能够输出a3=3就证明protected在友元函数中可调用
43     B b1;
44     b1.show_B();//若能够输出子类x=0就可证明protected在子类可调用
45     cout << "类外x=" << a3.x << endl;//若能够输出类外x=3就可证明protected在类外可调用
46     return 0;
47 }

调试后

42行显示a3=3

44行显示子类x=0

45行显示error：'int A::x' is private within this context（“int A:：x”在此上下文中是私有的）

由此可得，结论正确

3.证明public调用范围：类内，类外

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 class A
 6 {
 7 public:
 8     A():x(0){}
 9     A(int x):x(x){}
10     friend A operator+(const A &left ,const A &right);
11     void display1()
12     {
13         cout<< "x=" << x << endl;//可正常输出则证明可在类内调用
14     }
15 public://private访问属性
16     int x;
17 };
18 A operator+(const A &left ,const A &right)//友元函数
19 {
20     A temp;
21     temp.x = left.x + right.x;
22     return temp;
23 }
24 class B:public A
25 {
26 public:
27     void show_B()
28     {
29         cout << "子类x=" << x << endl;
30     }
31 private:
32     int y;
33 };
34 
35 
36 int main()
37 {
38     A a1(1);
39     A a2(2);
40     A a3;
41     a3 = a1 + a2;//运用了友元函数
42     a3.display1();//若能够输出a3=3就证明public在友元函数中可调用
43     B b1;
44     b1.show_B();//若能够输出子类x=0就可证明public在子类可调用
45     cout << "类外x=" << a3.x << endl;//若能够输出类外x=3就可证明public在类外可调用
46     return 0;
47 }

 

如图可知，全部正常输出

由此可知，结论正确

 

标签：调用,const,int,private,protected,类内,public
来源： https://www.cnblogs.com/zhangshengxin/p/14612259.html