C++中public/private/protected三种继承方式下基类成员对派生类的可见性探讨



原文: http://blog.csdn.net/zgjxwl/article/details/4804233

1.public继承方式下


#include <iostream>  
using namespace std;  
class Animal  
{  
public:  
    Animal(){}  
    void eat()  
    {  
        cout << "eat\n";  
    }  
protected:  
    void play()  
    {  
        cout << "play\n";  
    }  
private:  
    void drink()  
    {  
        cout << "drink\n";  
    }  
};  
class Giraffe: public Animal  
{  
public:  
    Giraffe(){}  
    void StrechNeck()  
    {  
        cout << "Strech neck \n";  
    }  
    void take()  
    {  
        eat();      // ok,公有继承下,基类的公有成员对派生类可见  
//      drink();    // error,公有继承下,基类的私有成员对派生类不可见,也就是说,派生类不能访问基类私有成员  
        play();     // ok,公有继承下,基类的保护成员对派生类可见  
    }  
};  
 
 
int main()  
{  
    Giraffe gir;  
    // 以下三条语句说明基类成员对派生类对象的可见性  
    gir.eat();              // ok,公有继承下,基类的公有成员对派生类对象可见  
    // gir.play();                  // error,公有继承下,基类的保护成员对派生类对象不可见  
    // gir.drink();                     // error,公有继承下,基类的私有成员对派生类对象不可见  
      
    // 下面一条语句说明基类成员对派生类的可见性  
    // 派生类(即对派生类的成员函数,派生类的友元函数和有元类可见性,和派生类对象无关)  
    gir.take();   
      
    gir.StrechNeck();  
    return 0;  

#include <iostream>
using namespace std;
class Animal
{
public:
 Animal(){}
 void eat()
 {
  cout << "eat\n";
 }
protected:
 void play()
 {
  cout << "play\n";
 }
private:
 void drink()
 {
  cout << "drink\n";
 }
};
class Giraffe: public Animal
{
public:
 Giraffe(){}
 void StrechNeck()
 {
  cout << "Strech neck \n";
 }
 void take()
 {
  eat();  // ok,公有继承下,基类的公有成员对派生类可见
//  drink(); // error,公有继承下,基类的私有成员对派生类不可见,也就是说,派生类不能访问基类私有成员
  play();  // ok,公有继承下,基类的保护成员对派生类可见
 }
};



int main()
{
 Giraffe gir;
 // 以下三条语句说明基类成员对派生类对象的可见性
 gir.eat();    // ok,公有继承下,基类的公有成员对派生类对象可见
 // gir.play();           // error,公有继承下,基类的保护成员对派生类对象不可见
 // gir.drink();                  // error,公有继承下,基类的私有成员对派生类对象不可见
 
 // 下面一条语句说明基类成员对派生类的可见性
 // 派生类(即对派生类的成员函数,派生类的友元函数和有元类可见性,和派生类对象无关)
 gir.take(); 
 
 gir.StrechNeck();
 return 0;
}


2.private继承方式下


#include <iostream>  
using namespace std;  
class Animal  
{  
public:  
    Animal(){}  
    void eat()  
    {  
        cout << "eat\n";  
    }  
protected:  
    void play()  
    {  
        cout << "play\n";  
    }  
private:  
    void drink()  
    {  
        cout << "drink\n";  
    }  
};  
class Giraffe: private Animal  
{  
public:  
    Giraffe(){}  
    void StrechNeck()  
    {  
        cout << "Strech neck \n";  
    }  
    void take()  
    {  
        eat();      // ok,私有继承下,基类的公有成员对派生类可见  
//      drink();    // error,私有继承下,基类的私有成员对派生类不可见,也就是说,派生类不能访问基类私有成员  
        play();     // ok,私有继承下,基类的保护成员对派生类可见  
    }  
};  
 
 
int main()  
{  
    Giraffe gir;  
    // 以下三条语句说明基类成员对派生类对象的可见性  
//  gir.eat();          // error,私有继承下,基类的公有成员对派生类对象不可见  
//  gir.play();         // error,私有继承下,基类的保护成员对派生类对象不可见  
//  gir.drink();                // error,私有继承下,基类的私有成员对派生类对象不可见  
 
    // 下面一条语句说明基类成员对派生类的可见性  
    // 派生类(即对派生类的成员函数,派生类的友元函数和有元类可见性,和派生类对象无关)  
    gir.take();   
 
    gir.StrechNeck();  
    return 0;  

#include <iostream>
using namespace std;
class Animal
{
public:
 Animal(){}
 void eat()
 {
  cout << "eat\n";
 }
protected:
 void play()
 {
  cout << "play\n";
 }
private:
 void drink()
 {
  cout << "drink\n";
 }
};
class Giraffe: private Animal
{
public:
 Giraffe(){}
 void StrechNeck()
 {
  cout << "Strech neck \n";
 }
 void take()
 {
  eat();  // ok,私有继承下,基类的公有成员对派生类可见
//  drink(); // error,私有继承下,基类的私有成员对派生类不可见,也就是说,派生类不能访问基类私有成员
  play();  // ok,私有继承下,基类的保护成员对派生类可见
 }
};



int main()
{
 Giraffe gir;
 // 以下三条语句说明基类成员对派生类对象的可见性
// gir.eat();   // error,私有继承下,基类的公有成员对派生类对象不可见
// gir.play();   // error,私有继承下,基类的保护成员对派生类对象不可见
// gir.drink();          // error,私有继承下,基类的私有成员对派生类对象不可见


 // 下面一条语句说明基类成员对派生类的可见性
 // 派生类(即对派生类的成员函数,派生类的友元函数和有元类可见性,和派生类对象无关)
 gir.take(); 


 gir.StrechNeck();
 return 0;
}


3.protected继承方式下


#include <iostream>  
using namespace std;  
class Animal  
{  
public:  
    Animal(){}  
    void eat()  
    {  
        cout << "eat\n";  
    }  
protected:  
    void play()  
    {  
        cout << "play\n";  
    }  
private:  
    void drink()  
    {  
        cout << "drink\n";  
    }  
};  
class Giraffe: protected Animal  
{  
public:  
    Giraffe(){}  
    void StrechNeck()  
    {  
        cout << "Strech neck \n";  
    }  
    void take()  
    {  
        eat();      // ok,保护继承下,基类的公有成员对派生类可见  
//      drink();    // error,保护继承下,基类的私有成员对派生类不可见,也就是说,派生类不能访问基类私有成员  
        play();     // ok,保护继承下,基类的保护成员对派生类可见  
    }  
};  
 
 
int main()  
{  
    Giraffe gir;  
    // 以下三条语句说明基类成员对派生类对象的可见性  
    //  gir.eat();          // error,保护继承下,基类的公有成员对派生类对象不可见  
    //  gir.play();         // error,保护继承下,基类的保护成员对派生类对象不可见  
    //  gir.drink();        // error,保护继承下,基类的私有成员对派生类对象不可见  
      
    // 下面一条语句说明基类成员对派生类的可见性  
    // 派生类(即对派生类的成员函数,派生类的友元函数和有元类可见性,和派生类对象无关)  
    gir.take();   
      
    gir.StrechNeck();  
    return 0;  
}


C++继承有以下几种方式: 1. 公有继承public inheritance):派生类基类继承成员派生类的访问属基类的访问属相同。在公有继承基类所有的公有成员派生类都是公有的,所有的保护成员派生类都是保护的,私有成员派生类是不可见的。 2. 保护继承protected inheritance):派生类基类继承成员派生类的访问属为保护成员。在保护继承基类所有的公有成员派生类都是保护的,所有的保护成员派生类都是保护的,私有成员派生类是不可见的。 3. 私有继承private inheritance):派生类基类继承成员派生类的访问属为私有成员。在私有继承基类所有的公有成员派生类都是私有的,所有的保护成员派生类也都是私有的,私有成员派生类是不可见的。 对于基类成员,不同的继承方式派生类的访问属有不同的限制。公有继承基类的公有成员派生类仍然是公有的,保护成员派生类仍然是保护的,私有成员派生类不可见。保护继承基类的公有和保护成员派生类都是保护的,私有成员派生类不可见。私有继承基类的所有成员派生类都是私有的,即使是公有成员和保护成员也是私有的。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值