浅析c++ public protected private的访问控制

个人体会：继承并不是基类的东西全是你的，当出现多次间接继承的时候，这个问题就凸显出来了

c++中private,public,protected的访问控制

第一:private,public,protected方法的访问范围.（public继承下）

private: 只能由该类中的函数、其友元函数访问,不能被任何其他访问，该类的对象也不能访问.

protected: 可以被该类中的函数、子类的函数、以及其友元函数访问,但不能被该类的对象访问

public: 可以被该类中的函数、子类的函数、其友元函数访问,也可以由该类的对象访问

注：友元函数包括两种：设为友元的全局函数，设为友元类中的成员函数

第二:类的继承后方法属性变化:

使用private继承,父类的所有方法在子类中变为private;

使用protected继承,父类的protected和public方法在子类中变为protected,private方法不变;

使用public继承,父类中的方法属性不发生改变; 

1.public继承方式下

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3. class Animal  
4. {  
5. public:  
6.     Animal(){}  
7.     void eat()  
8.     {  
9.         cout << "eat/n";  
10.     }  
11. protected:  
12.     void play()  
13.     {  
14.         cout << "play/n";  
15.     }  
16. private:  
17.     void drink()  
18.     {  
19.         cout << "drink/n";  
20.     }  
21. };  
22. class Giraffe: public Animal  
23. {  
24. public:  
25.     Giraffe(){}  
26.     void StrechNeck()  
27.     {  
28.         cout << "Strech neck /n";  
29.     }  
30.     void take()  
31.     {  
32.         eat();      // ok,公有继承下,基类的公有成员对派生类可见  
33. //      drink();    // error,公有继承下,基类的私有成员对派生类不可见，也就是说，派生类不能访问基类私有成员  
34.         play();     // ok,公有继承下,基类的保护成员对派生类可见  
35.     }  
36. };  
37.   
38.   
39. int main()  
40. {  
41.     Giraffe gir;  
42.     // 以下三条语句说明基类成员对派生类对象的可见性  
43.     gir.eat();              // ok,公有继承下,基类的公有成员对派生类对象可见  
44.     // gir.play();                  // error,公有继承下,基类的保护成员对派生类对象不可见  
45.     // gir.drink();                     // error,公有继承下,基类的私有成员对派生类对象不可见  
46.       
47.     // 下面一条语句说明基类成员对派生类的可见性  
48.     // 派生类(即对派生类的成员函数，派生类的友元函数和有元类可见性，和派生类对象无关)  
49.     gir.take();   
50.       
51.     gir.StrechNeck();  
52.     return 0;  
53. }  

2.private继承方式下

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3. class Animal  
4. {  
5. public:  
6.     Animal(){}  
7.     void eat()  
8.     {  
9.         cout << "eat/n";  
10.     }  
11. protected:  
12.     void play()  
13.     {  
14.         cout << "play/n";  
15.     }  
16. private:  
17.     void drink()  
18.     {  
19.         cout << "drink/n";  
20.     }  
21. };  
22. class Giraffe: private Animal  
23. {  
24. public:  
25.     Giraffe(){}  
26.     void StrechNeck()  
27.     {  
28.         cout << "Strech neck /n";  
29.     }  
30.     void take()  
31.     {  
32.         eat();      // ok,私有继承下,基类的公有成员对派生类可见  
33. //      drink();    // error,私有继承下,基类的私有成员对派生类不可见，也就是说，派生类不能访问基类私有成员  
34.         play();     // ok,私有继承下,基类的保护成员对派生类可见  
35.     }  
36. };  
37.   
38.   
39. int main()  
40. {  
41.     Giraffe gir;  
42.     // 以下三条语句说明基类成员对派生类对象的可见性  
43. //  gir.eat();          // error,私有继承下,基类的公有成员对派生类对象不可见  
44. //  gir.play();         // error,私有继承下,基类的保护成员对派生类对象不可见  
45. //  gir.drink();                // error,私有继承下,基类的私有成员对派生类对象不可见  
46.   
47.     // 下面一条语句说明基类成员对派生类的可见性  
48.     // 派生类(即对派生类的成员函数，派生类的友元函数和有元类可见性，和派生类对象无关)  
49.     gir.take();   
50.   
51.     gir.StrechNeck();  
52.     return 0;  
53. }  

3.protected继承方式下

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3. class Animal  
4. {  
5. public:  
6.     Animal(){}  
7.     void eat()  
8.     {  
9.         cout << "eat/n";  
10.     }  
11. protected:  
12.     void play()  
13.     {  
14.         cout << "play/n";  
15.     }  
16. private:  
17.     void drink()  
18.     {  
19.         cout << "drink/n";  
20.     }  
21. };  
22. class Giraffe: protected Animal  
23. {  
24. public:  
25.     Giraffe(){}  
26.     void StrechNeck()  
27.     {  
28.         cout << "Strech neck /n";  
29.     }  
30.     void take()  
31.     {  
32.         eat();      // ok,保护继承下,基类的公有成员对派生类可见  
33. //      drink();    // error,保护继承下,基类的私有成员对派生类不可见，也就是说，派生类不能访问基类私有成员  
34.         play();     // ok,保护继承下,基类的保护成员对派生类可见  
35.     }  
36. };  
37.   
38.   
39. int main()  
40. {  
41.     Giraffe gir;  
42.     // 以下三条语句说明基类成员对派生类对象的可见性  
43.     //  gir.eat();          // error,保护继承下,基类的公有成员对派生类对象不可见  
44.     //  gir.play();         // error,保护继承下,基类的保护成员对派生类对象不可见  
45.     //  gir.drink();        // error,保护继承下,基类的私有成员对派生类对象不可见  
46.       
47.     // 下面一条语句说明基类成员对派生类的可见性  
48.     // 派生类(即对派生类的成员函数，派生类的友元函数和有元类可见性，和派生类对象无关)  
49.     gir.take();   
50.       
51.     gir.StrechNeck();  
52.     return 0;  
53. }