C++继承大全（附代码）

 C++的继承关系
 专业术语：
 父类（基类）
 子类（派生类）
 
实验1：
定义一个父类，
子类用pubilc继承父类；外部（如main函数），外部实例化子类对象时只能访问里面的public的成员
如果是private或者protected方式去继承父类，那么父类里面的成员的不能访问；

    class father//父类
{
public:
    int a;
private:
    int b;`在这里插入代码片`
protected:
    int c;
    father();
};
class son:public father//public 继承
{

};
int main()
{
    son *p=new son();
    p->a=20;
    cout << "Hello World!" << endl;
    return 0;
}

实验2：
子类继承父类，无论是哪一种方式继承，从父类继承下来的成员，*在子类内部而言*，只有共有的或者受保护的成员才能够进行访问

补充：如果要访问父类私有成员，不能直接访问，但可以在父类封装一个公有或者受保护的函数进行访问。

class father
{
public:
    int a;
private:
    int b;
protected:
    int c;
    father();
};
class son1:protected father//换成public也行,但是不能private
{
public:
    int e=c;
    //int test=b //error b是父类的私有类
    int he=a;
    son1();
};

实验2.1：关于子类和父类的构造/析构函数，当子类实例化一个对象，构造：首先调用父类的构造函数，在调用子类的构造函数，析构：先析构子类的析构函数，在析构父类的析构函数。可以用生活中的例子理解一下。

 class father
{
public:
    int a;
    father()
    {
        printf("父类构造函数\n");
    }
    ~ father()
    {
        printf("父类析构函数\n");
    }
private:
    int b;
protected:
    int c;

};
class son1:protected father
{
public:
    int e=c;
    //int test=b //error b是父类的私有类
    int he=a;
    son1()
    {
        printf("子类构造函数\n");
    }
    ~ son1()
    {
        printf("子类析构函数\n");
    }
};
int main()
{
   // son *p=new son();
    son1 q;
    //p->a=20;
    cout << "分界线" << endl;
    return 0;
}

实验2.2：子类和父类可以的成员变量可以定义同名
实验2.3：如果子类和父类同名，那么是实例化对象.成员变量，默认是子类的，如果要通过子类访问父类，可以实例化对象.父类：：成员变量。

int main()
{
   // son *p=new son();
    son1 q;
    cout<<"子类的成员地址："<<&q.a<<endl;
    cout<<"通过父类访问子类的成员a地址"<<&q.father::a<<endl;
    //p->a=20;
    //cout << "分界线" << endl;
    return 0;
}

3.当父类中含有其他的类，通过子类调用时先调用父类中的其他类的构造。在调用父类构造，最后调用子类构造，析构则反过来。

class other
{
public:
    other()
    {
        printf("这是父类的朋友构造函数\n");
    }
};

class father
{
  public:
    int a;
   other *w=new other();
    father()
    {
        printf("父类构造函数\n");
    }
    father(int a)
    {
        printf("父类有参构造函数\n");
    }
    ~ father()
    {
        printf("父类析构函数\n");
    }
private:
    int b;
protected:
    int c;

};
class son2 :public father
{
    int w;
public:
    son2():father(5)
    {
        printf("son2的无参构造函数\n");
    }
    son2(int w)
    {
        w=66;
        this->w=w;
        printf("son2的有参构造 %d\n",w);
    }
};
int main()
{
    son2 re；
    return 0;
}

4.虛函數
多继承我们讨论3类：
链式继承、扇形继承、菱形继承

在继承关系中，如果里面有相同函数（函数名一样，参数也一样），我们为了统一调用接口，采用虚函数机制。在最原始的类用上关键字 virtual 修饰该成员函数那么它的子类中，
孙子类等等，从它这里继承出来的类，如果具备合它相同的函数名，并且参数相同，那么就全部变成了虚函数

是我们C++多态的一个体现
虚函数，原来函数重载不一样，函数重载在编译的阶段就把代码定下来了，运行函数调用，形参不一样，会自动匹配，
静态多态（静态联编）

动态多态(动态联编)
虚函数，说白就其实所谓函数定义，进行是一个函数指针，只要当运行的时候，根据对象地址特性，来决定调用哪一个子类对象的同名虚函数。

class father
{
  public:
    int a;
   other *w=new other();
    father()
    {
        printf("父类构造函数\n");
    }
    father(int a)
    {
        printf("父类有参构造函数\n");
    }
    ~ father()
    {
        printf("父类析构函数\n");
    }
    virtual  void introude()
    {
        printf("这是爸爸的类\n");
    }
private:
    int b;
protected:
    int c;

};

class son:public father//public 继承
{
 public:
    void introude()
    {
        printf("这是儿子的类\n");
    }
};
class son_son:public son//public 继承
{
 public:
    void introude()
    {
        printf("这是孙子的类\n");
    }
};

void test(father *p)
{
    p->introude();
}
int main()
{
    son p;
    //son1 q;
    //son2 re;
    father wq;
    son_son wo;
    test(&p);
    test(&wq);
    test(&wo);
    //cout<<"子类的成员地址："<<&q.a<<endl;
    //cout<<"通过父类访问子类的成员a地址"<<&q.father::a<<endl;
    //p->a=20;
    //cout << "分界线" << endl;
    return 0;
}