友元 继承 public private protected

http://blog.csdn.net/ycf74514/article/details/49053041

1 友元函数和友元类均可以访问private \protected成员；

2 友元函数和友元类能够引用类中的private \protected成员，但是在其内部引用时必须通过对象引用，比如函数体中a.x，b.x，a.y，b.y都是类的私有成员，他们是通过对象引用的。

3 友元函数在外部调用时，不需要通过基类的对象 “  . ”  或者对象指针 “-> ” 来调用，因为它是一个普通函数，不是类成员函数，调用跟普通函数方式一样；

4 友元函数在基类外部定义，且定义时不需要加 :: 符号。

5 友元函数和友元类在基类内部声明时在哪个位置都一样，包括public\private\protected位置;

一：成员的访问权限

1: public访问权限

    一个类的public成员变量、成员函数，可以通过类的成员函数、类的实例变量进行访问

   <实际上，类的成员函数，可以访问本类内的任何成员变量和成员函数>

   

[cpp] view plain copy

1. #include<iostream>  
2. #include<string>  
3.   
4. using namespace std;  
5.   
6. class AccessTest  
7. {  
8.     public:  
9.         int pub_mem;  
10.         int pub_fun(){};  
11.     protected:  
12.         int prot_mem;  
13.         int prot_fun(){};  
14.     private:  
15.         int priv_memb;  
16.         int priv_fun(){};  
17.           
18. };  
19.   
20. int main()  
21. {  
22.     AccessTest at;  
23.     at.pub_mem;     //OK, 类变量可以访问public成员  
24.     at.pub_func();  //OK, 访问public成员函数是没有问题的  
25.       
26.   return 0;  
27. }  

2：protected访问权限

     一个类的protected成员变量、成员函数，无法通过类的实例变量进行访问。但是可以通过类的友元函数、友元类进行访问。

[cpp] view plain copy

1. #include<string>  
2. #include<iostream>  
3.   
4. using namespace std;  
5.   
6. class AccessTest  
7. {  
8.     friend void Atest();  
9.     friend class CAtest;  
10.     public:  
11.         int pub_mem;  
12.         void pub_fun(){}  
13.     protected:  
14.         int prot_mem;  
15.         void prot_fun(){}  
16.     private:  
17.         int priv_memb;  
18.         void priv_fun(){}  
19.           
20. };  
21.   
22. class CAtest  
23. {  
24.     public:  
25.         void x()  
26.         {  
27.           AccessTest t;  
28.           t.prot_fun();      //OK,友元类可以访问protected成员函数  
29.           int x=t.prot_mem;  //OK,友元类可以访问protected成员变量  
30.        }  
31. };  
32.   
33. void Atest()  
34. {  
35.     AccessTest t;  
36.     t.prot_fun();     //OK,友元函数可以访问protected成员函数  
37.     int x=t.prot_mem;  //OK,友元函数可以访问protected成员变量  
38. }  
39.   
40. int main()  
41. {  
42.     AccessTest at;  
43.     at.prot_mem;      //ERROR,类实例变量无法访问protected成员变量  
44.     at.prot_fun();    //ERROR,类实例变量无法访问protected成员函数  
45.     Atest();  
46.     return 0;  
47. }  

3：private访问权限

     一个类的private成员变量、成员函数，无法通过类的实例变量进行访问。但是可以通过类的友元函数、友元类进行访问。

[cpp] view plain copy

1. #include<iostream>  
2. #include<string>  
3.   
4. using namespace std;  
5.   
6. class AccessTest  
7. {  
8.     friend void Atest();  
9.     friend class CAtest;  
10.     public:  
11.         int pub_mem;  
12.         void pub_fun(){}  
13.     protected:  
14.         int prot_mem;  
15.         void prot_fun(){}  
16.     private:  
17.         int priv_memb;  
18.         void priv_fun(){}  
19.           
20. };  
21.   
22. class CAtest  
23. {  
24.     public:  
25.     void x()  
26.     {  
27.            AccessTest t;  
28.                t.priv_fun();       //OK,友元类可以访问private成员函数  
29.            int x=t.priv_memb;  //OK,友元类可以访问private成员变量  
30.         }  
31. };  
32.   
33. void Atest()  
34. {  
35.     AccessTest t;  
36.     t.priv_fun();       //OK,友元函数可以访问private成员函数  
37.     int x=t.priv_memb;  //OK,友元函数可以访问private成员变量  
38. }  
39.   
40. int main()  
41. {  
42.     AccessTest at;  
43.     at.priv_memb;       //ERROR,类实例变量无法访问private成员变量  
44.     at.priv_fun();      //ERROR,类实例变量无法访问private成员函数  
45.     Atest();  
46.         return 0;  
47. }  

到现在，是否感觉私有访问属性，和保护属性没有什么区别？区别主要体现在继承上面。下面将会讲到。

总结：public在任何地方都能访问，protected只能在派生类中访问， private只能在友元中访问。

二：继承的访问权限控制

1：public继承

     派生类通过public继承，基类的各种权限不变 。

     派生类的成员函数，可以访问基类的public成员、protected成员，但是无法访问基类的private成员。

     派生类的实例变量，可以访问基类的public成员，但是无法访问protected、private成员，仿佛基类的成员之间加到了派生类一般。

     可以将public继承看成派生类将基类的public,protected成员囊括到派生类，但是不包括private成员。

[cpp] view plain copy

1. #include<iostream>  
2. #include<string>  
3.   
4. using namespace std;  
5.   
6. class AccessTest  
7. {  
8.     public:  
9.         int pub_mem;  
10.         void pub_fun(){}  
11.     protected:  
12.         int prot_mem;  
13.         void prot_fun(){}  
14.     private:  
15.         int priv_memb;  
16.         void priv_fun(){}  
17.           
18. };  
19.   
20. class DAccessTest:public AccessTest  
21. {  
22.     public:  
23.         void test()  
24.         {  
25.             int x=pub_mem;     //OK  
26.             pub_fun();         //OK  
27.               
28.             int y=prot_mem;    //OK  
29.             prot_fun();        //OK  
30.               
31.             int z=priv_memb;   //ERROR  
32.             priv_fun();        //ERROR  
33.         }  
34.           
35. };  
36.   
37.   
38.   
39. int main()  
40. {  
41.     DAccessTest dt;  
42.     int x=dt.pub_mem;    //OK  
43.     int y=dt.prot_mem;   //ERROR  
44.     int z=dt.priv_memb;  //ERROR  
45.         return 0;  
46. }  

2：protected继承

     派生类通过protected继承，基类的public成员在派生类中的权限变成了protected 。protected和private不变。

     派生类的成员函数，可以访问基类的public成员、protected成员，但是无法访问基类的private成员。

     派生类的实例变量，无法访问基类的任何成员，因为基类的public成员在派生类中变成了protected。

     可以将protected继承看成派生类将基类的public,protected成员囊括到派生类，全部作为派生类的protected成员，但是不包括private成员。

     private成员是基类内部的隐私，除了友元，所有人员都不得窥探。派生类的友元，都不能访问

[cpp] view plain copy

1. #include<iostream>  
2. #include<string>  
3.   
4. using namespace std;  
5.   
6. class AccessTest  
7. {  
8.     friend void Atest();  
9.     friend class CAtest;  
10.     public:  
11.         int pub_mem;  
12.         void pub_fun(){}  
13.     protected:  
14.         int prot_mem;  
15.         void prot_fun(){}  
16.     private:  
17.         int priv_memb;  
18.         void priv_fun(){}  
19.           
20. };  
21.   
22. class DAccessTest:protected AccessTest  
23. {  
24.     public:  
25.         void test()  
26.         {  
27.             int x=pub_mem;     //OK  
28.             pub_fun();         //OK  
29.               
30.             int y=prot_mem;    //OK  
31.             prot_fun();        //OK  
32.               
33.             int z=priv_memb;   //ERROR  
34.             priv_fun();        //ERROR  
35.         }  
36.           
37. };  
38.   
39.   
40.   
41. int main()  
42. {  
43.     DAccessTest dt;  
44.     int x=dt.pub_mem;    //ERROR，基类的成员现在是派生类的保护成员  
45.     int y=dt.prot_mem;   //ERROR，基类的成员现在是派生类的保护成员  
46.     int z=dt.priv_memb;  //ERROR  
47.   return 0;  
48. }  

3：private继承

     派生类通过private继承，基类的所有成员在派生类中的权限变成了private。

     派生类的成员函数，可以访问基类的public成员、protected成员，但是无法访问基类的private成员。

     派生类的实例变量，无法访问基类的任何成员，因为基类的所有成员在派生类中变成了private。

     可以将private继承看成派生类将基类的public,protected成员囊括到派生类，全部作为派生类的private成员，但是不包括private成员。

     private成员是基类内部的隐私，除了友元，所有人员都不得窥探。派生类的友元，都不能访问

[cpp] view plain copy

1. #include<iostream>  
2. #include<string>  
3.   
4. using namespace std;  
5.   
6. class AccessTest  
7. {  
8.     friend void Atest();  
9.     friend class CAtest;  
10.     public:  
11.         int pub_mem;  
12.         void pub_fun(){}  
13.     protected:  
14.         int prot_mem;  
15.         void prot_fun(){}  
16.     private:  
17.         int priv_memb;  
18.         void priv_fun(){}  
19.           
20. };  
21.   
22. class DAccessTest:private AccessTest  
23. {  
24.     public:  
25.         void test()  
26.         {  
27.             int x=pub_mem;     //OK  
28.             pub_fun();         //OK  
29.               
30.             int y=prot_mem;    //OK  
31.             prot_fun();        //OK  
32.               
33.             int z=priv_memb;   //ERROR  
34.             priv_fun();        //ERROR  
35.         }  
36.           
37. };  
38.   
39.   
40.   
41. int main()  
42. {  
43.     DAccessTest dt;  
44.     int x=dt.pub_mem;    //ERROR，基类的成员现在是派生类的私有成员  
45.     int y=dt.prot_mem;   //ERROR，基类的成员现在是派生类的私有成员  
46.     int z=dt.priv_memb;  //ERROR, private成员无法访问  
47.   return 0;  
48. }  

总结：继承修饰符，就像是一种筛子，将基类的成员筛到派生类。public、protected、private，就是筛子的眼。

          通过public继承，所有基类成员（除了private），public、protected都到了派生类里面，public筛眼比较大，不会改变访问权限。

          通过protected继承，所有基类成员（除了private），public、protected都到了派生类里面，protected筛眼大小适中，所有过来的成员都变成了protected。

          通过private继承，所有基类成员（除了private），public、protected都到了派生类里面，private筛眼最小，所有过来的成员都变成了private。

  

PS:关于class和struct的区别

1：class不写修饰符，成员默认是private的，而struct 默认是public的

[cpp] view plain copy

1. class Base   //默认private  
2. {  
3.     int a;  
4.     int b;  
5. }  
6.   
7. Base ba;  
8. int x=ba.a;//错误  
9. int y=ba.b;//错误  
10.   
11. struct St  //默认public  
12. {  
13.     int a;  
14.     int b;  
15. }；  
16.   
17. St st;  
18. int x=st.a; //OK  
19. int y=st.b;//OK  

2:class的继承默认是private的，而struct默认是public的

[cpp] view plain copy

1. class Base{...};  
2. class Derive:Base{...}  //private继承  
3.   
4. struct BStruct{...};  
5. struct DStruct:BStruct{...};//public继承