C++继承的相关概念

继承最主要的作用是实现多态

*无论是哪种继承，对象都不能访问父类的私有成员

公有继承

#include <iostream>

using namespace std;

class base
{
private:
    int x;
};

class D : public base   //D公有继承父类base
{
public:
   int y;
};

int main()
{
    cout << sizeof(D) << endl;  //大小为8字节，说明子类继承父类时
                                //不仅仅只继承父类的公有部分，推翻之前的只继承父类公有部分的说法
    return 0;
}

#include <iostream>

using namespace std;

class base
{
public:
    base() : x(0)
    {}
    ~base(){}
public:
    void show_base()
    {
        cout << "base :: show_base()!" << endl;
    }
public:
    void SetX(int data)
    {
        x = data;
    }
protected:    //保护属性只有在继承中才可以体现其作用
    void print_base()
    {
        cout << "base :: print_base()!" << endl;
    }
private:
    int x;
};


//公有继承：
//    相当于把父类的所有信息（除了父类的构造和析构函数）全部继承，
// 父类的私有，公有，保护继承到子类后仍维持之前的属性
//
//对于派生类(子类)内部：
//    对于父类的私有成员无论什么继承方式，子类都不可直接访问，要通过父类的保护或公有方法进行访问
//    公有继承不可以直接访问父类的私有成员，但可以直接访问父类的公有和保护成员
//    
//对于对象：
//    公有继承时父类的保护成员不可以直接访问
//    通过对象永远只能访问公有方法；保护和私有永远不可通过对象访问
//
class D : public base   //D公有继承父类base
{
public:
    D() : y(0)
    {}
    ~D()
    {}
public:
    void setdata(int data)
    {
        y = data;   //ok,D的公有方法访问自己的私有数据
      //x = data;   //不可以，虽然D继承了父类相当于D也拥有x成员，
                    //但是不能直接对父类的私有成员操作,
        SetX(data); //要想访问父类的私有成员必须通过父类的公有方法(无论哪种继承方式)
    }
public:
    void show_D()
    {        
        cout << "D :: show_D()!" << endl;
        show_base();   //子类可以直接调用父类的公有方法
    } 
protected:
    void print_D()
    {
        cout << "D :: print()_D" << endl;
    }
private:
   int y;
};


//划分为两个层次
//1.派生类内部能否访问父类
//2.对象能否访问
int main()
{
    base b;    //b不可直接访问其私有数据（要通过公有方法）
               //b不可调用其保护方法，只能调用其公有方法


    //针对派生子类
    D d;
    d.show_base();    //可以访问
    d.show_D();       //可以访问
  //d.print_base();   //d对象不可以访问父类的保护成员
  //d.print_D();      //d对象不可以访问子类的保护成员


    cout << sizeof(D) << endl;   //大小都为8字节，无论是公有，保护还是私有继承父类
    return 0;
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
保护继承

#include <iostream>

using namespace std;

class base
{
public:
    base() : x(0)
    {}
    ~base(){}
public:
    void show_base()
    {
        cout << "base :: show_base()!" << endl;
    }
public:
    void SetX(int data)
    {
        x = data;
    }
protected:
    void print_base()
    {
        cout << "base :: print_base()!" << endl;
    }
private:
    int x;
};


//保护继承：
//    保护继承时，相当于将父类的除去构造和析构的所有信息都继承，
//    不过继承为子类的保护成员(原先的保护和公有)（原先的私有保护继承后仍为私有）
//对于派生类内部：
//    子类不能访问父类的私有成员
//    子类可以访问父类的公有和保护成员
//
//对于对象：
//    子类对象可以访问自身的公有成员，
//    但子类对象不可访问父类的公有成员
//

class D :  protected base   //此处的继承方式针对的是对象的操作的限制
{
public:
    D() : y(0)
    {}
    ~D()
    {}
public:
    void setdata(int data)
    {
        y = data;   //ok,D的公有方法访问自己的私有数据
    }
public:
    void show_D()
    {        
        cout << "D :: show_D()!" << endl;
        show_base();    //保护继承，可以访问父类的公有成员  
        print_base();   //保护继承，可以访问父类的保护成员
    } 
protected:
    void print_D()
    {
        cout << "D :: print()_D" << endl;
    }
private:
   int y;
};


//划分为两个层次
//1.派生类内部能否访问父类
//2.对象能否访问


int main()
{
    D d;
    d.show_D();      //可以
  //d.show_base();   //不可以访问，对于子类该方法是保护属性，子类对象不可访问父类的保护成员
}

私有继承

#include <iostream>

using namespace std;

class base
{
public:
    base() : x(0)
    {}
    ~base(){}
public:
    void show_base()
    {
        cout << "base :: show_base()!" << endl;
    }
public:
    void SetX(int data)
    {
        x = data;
    }
protected:
    void print_base()
    {
        cout << "base :: print_base()!" << endl;
    }
private:
    int x;
};


//私有继承：
//    相当于将父类的所有信息（除去构造和析构）都拷贝至子类的私有部分
//
//对于派生类内部：
//    私有继承仅仅是将父类的成员当作i是子类的私有成员，但是访问方式仍不变
//
//对于对象：
//    父类的所有信息都不可访问（包括公有和保护成员）；因为父类的一切对于子类对象来说都是私有的，所以子类对象不可直接访问


class D :  private base   //此处的继承方式针对的是对象的操作的限制
{
public:
    D() : y(0)
    {}
    ~D()
    {}
public:
    void setdata(int data)
    {
        y = data;   //ok,D的公有方法访问自己的私有数据
    }
public:
    void show_D()
    {        
        cout << "D :: show_D()!" << endl;
        show_base();    //可以访问，虽然继承下来后作为子类的私有成员，
                        //但是子类的公有方法可以访问其私有成员
        print_base();   //也可以访问父类的保护成员（原因同上）
    } 
protected:
    void print_D()
    {
        cout << "D :: print()_D" << endl;
    }
private:
   int y;
};


//私有继承的用处：
//    C公有继承了D，D私有继承了base，但base在D中是私有属性，C继承了D之后，
//    C不能直接访问base，因为在D内base相当于D的私有成员，
//    所以对C来说无法访问父类D的私有成员；
//

class C : public D
{
public:
    void show_C()
    {
      //show_base();   //不可访问（私有继承（多重继承时）），但可以在保护和公有继承时访问
    }
}
//划分为两个层次
//1.派生类内部能否访问父类
//2.对象能否访问


int main()
{
    D d;
}