继承（知识点汇总）

在c++中可重用性是通过“继承”这一机制来实现的。。。。。
1.那么什么是继承呢？
简单说：龙生龙，凤生凤老鼠的儿子会打洞

用代码举个最简单的继承例子（单继承方式）

class A
{
public:
    int _a;
    void Display1()
    {
       cout<<_a<<endl;
    }
};
class B:public A  //B公有继承了A
{
public:
    int _b;
    void Display2()
    {
       cout<<_a<<endl;//派生类可以访问基类的公有成员
       cout<<_b<<endl;
    }
};
void TunTest()
{
    A a;
    a._a = 10;
    a.Display1();
    B b;//B公用继承了A的成员函数和成员变量
    b._a = 20;//在类外可以通过B访问A中成员变量的_a
    b.Display1();//在类外也可以通过B访问A中成员函数的Display1
}
int main()
{
    TunTest();
    system("pause");
    return 0;
}

通过以上代码大致解析一下继承~

2. 接下来我们就来一一探讨一下，在什么情况下派生类可以访问基类的所有成员变量和函数–》》

基类的成员函数或者成员变量有三种类型
public/protected/private

而继承的方式有三种形式：public/protected/private,那么问题是它们究竟是怎么访问的呢？？？
下面我们在VS2013上对各种情况试一下~

（一）public继承

class A
{
public:
    void Display1()
    {
        cout <<" Display1() "<< endl;
    }
public:
    int _a1;
protected:
    int _a2;
private:
    int _a;
};
class B:public A//公有继承
{
public:
    void Display2()
    {
        cout << " Display2() " << endl;
        cout << _a1 << endl;//可以访问
        cout << _a2 << endl;//可以访问
        //cout << _a << endl;//不可访问，只能在A类中访问
    }
public:
    int _b1;
protected:
    int _b2;
private:
    int _b;

};
void TunTest()
{
    A a;
    a._a1 = 10;
    //a._a2 = 12;//不可访问
    //a._a = 11;//不可访问
    a.Display1();
    B b;
    b._a1 = 10;//A的公有成员可以通过派生类B访问
    //b._a2 = 12;//A的保护成员在类外不可访问
    //b._a = 11;//不可访问
    b.Display1();
}

  可以看到在public继承中，基类的公有成员和保护成员在派生类中保持原有访问属性，其私有成员仍为基类私有。

总结：public继承规则：“is-a”方式，即就是每个基类可用的成员对于派生类也都可用，基类的非私有成员在派生类的访问属性不变~

（二）protected继承

class C :protected A//保护继承
{
public:
    void Display3()
    {
        cout << " Display3() " << endl;
        cout << _a1 << endl;
        cout << _a2 << endl;
        //cout << _a << endl;//不可以访问
    }
public:
    int _c1;
protected:
    int _c2;
private:
    int _c;

};
void TunTest()
{
    A a;
    a._a1 = 10;
    //a._a2 = 12;//保护成员在类外不可访问
    //a._a = 11;//私有成员在类外不可访问
    a.Display1();
    C c;
    //c._a1= 10;//不可访问
    //c._a2 = 12;//不可访问
    //c._a= 11;//不可访问
    //c.Display1();//不可访问
    c.Display3();
    c._c1;
    //c._c2;//不可访问
    //c._c;//不可访问
}
int main()
{
    TunTest();
    system("pause");
    return 0;
}

运行结果截图：

  从运行结果来看，在protected继承中，基类的公有成员和保护成员在派生类中成了保护成员，其私有成员仍为基类私有；保护成员的意思是：不能被外界引用，但可以被派生类的成员引用

总结：protected继承规则：“has-a“方式，即就是基类的非私有成员都成为派生类的保护成员

（三）私有继承

class D :private A//私有继承
{
public:
    void Display4()
    {
        cout << " Display4() " << endl;
        cout << _a1 << endl;
        cout << _a2 << endl;
        //cout << _a << endl;//不可以访问
    }
public:
    int _d1;
protected:
    int _d2;
private:
    int _d;

};
void TunTest()
{
    A a;
    a._a1 = 10;
    //a._a2 = 12;//保护成员在类外不可访问
    //a._a = 11;//私有成员在类外不可访问
    a.Display1();
    D d;
    //d._a1= 10;//不可访问
    //d._a2 = 12;//不可访问
    //d._a= 11;//不可访问
    //d.Display1();//不可访问
    d.Display4();
    d._d1;
    //d._d2;//保护成员在类外不可访问不可访问
    //d._d;//私有成员在类外不可访问
}
int main()
{
    TunTest();
    system("pause");
    return 0;
}

运行结果分析~
   在private继承中，在基类的public成员变为private成员，在派生类中可以访问，基类的protected成员也变为派生类的private成员，在派生类中也可以访问，但基类的private成员在基类中不可访问~

总结：private继承规则：“has-a“方式，即就是基类的非私有成员都成为派生类的私有成员。

3.派生类的构造函数和析构函数

（一）派生类的构造函数
（1） 如果类中没有显式的定义构造函数和析构函数，系统会自动设置一个默认的，在定义类对象时自动调用这个默认的
（2）基类的构造函数和析构函数是不能继承的，那么继承关系中构造函数和析构函数是怎么调用的呢？？
我们来看一段代码~

class A
{
public:
    A()//无参的构造函数
    {
        cout << "A() "<< endl;
    }
    void Display1()
    {
        _a = 20;
        cout << _a << endl;
    }
    ~A()
    {
        cout << "~A" << endl;
    }
private:
    int _a;

};
class B :public A
{
public:
    B()
    {
        cout << "B()" << endl;
    }
    void Display2()
    {
        _b = 30;
        cout << _b << endl;
    }
    ~B()
    {
        cout << "~B" << endl;
    }
private:
    int _b;
};
void FunTest()
{
    B b;
    b.Display1();
}
int main()
{
    FunTest();
    system("pause");
    return 0;
}

调用结果分析如下：

说明：
（1）定义派生类构造函数的一般形式：
派生类构造函数名（总参数表）：基类构造函数名（参数表），子对象名（参数表）
{
派生类中新增数据成员初始化语句
}
（2）基类没有缺省构造函数，派生类必须要在初始化列表中显式给出基类名和参数列表
（3）基类没有定义构造函数，则派生类可以不用定义，全部用缺省构造函数
（4）基类定义了带有形参表的构造函数，派生类就一定得定义构造函数

4继承与转换（遵循赋值兼容规则）

对上面的代码验证一下：

void FunTest()
{
    A a;
    A*pa = &a;
    A& a1 = a;
    B b;
    B*pb = &b;
    B& b1 = b;
    *pa = b;//可以
    //*pb = a;
    a = b;//可以
    //b = a;
    a1 = b1;//可以
    //b1 = a1;//不可以
    b.Display1();
}

运行结果如下：

总结：子类对象可以赋值给父类对象，反之则不行；
父类的指针/引用可以指向子类的对象，反之不可以。

5.继承中的”同名隐藏“
代码说明：

class A
{
public:
    int num=20;
    void Display()
    {
        cout << num << endl;
    }
};
class B:public A
{
public:
    int num = 30;
    void Display()
    {
        cout << num<< endl;
    }
};
void FunTest()
{
    B b;
    b.Display();
    A a;
    a.Display();//可以通过这种方式对基类中的成员函数进行访问
}
int main()
{
    FunTest();
    system("pause");
    return 0;
}

看一下函数调用的反汇编~

总结：子类和父类中出现同名成员时，子类会覆盖父类从而对成员直接访问

7.单继承，多继承（菱形继承）

就菱形继承我们多来探讨一番~
代码：

class A
{
public:
    int _a;
};
class B :public A
{
public:
    int _b;
};
class C :public A
{
public:
    int _c;
};
class D :public B, public C
{
public:
    int _d;
};

菱形对象模型如下所示：

对于以上菱形继承就会出现以下这种情况~

那该如何解决呢？？？
在c++中，提供了一种解决方法——虚基类，使得在继承间接共同基类时只保留一份成员

8.那接下来，我们就来聊一下”虚基类“
（1）声明：
class 派生类名：virtual 继承方式 基类名

class A//声明基类A
{
public:
    int _a;
};
class B : virtual public A//声明类B是类A的公用派生类，A是B的虚基类
{
public:
    int _b;
};
class C :virtual public A//声明类C是类A的公用派生类，A是C的虚基类
{
public:
    int _c;
};
class D :public B, public C
{
public:
    int _d;
};
void Test()
{
    D d;
    d._a = 1;
    d._b = 2;
    d._c = 3;
    d._d = 4;
    cout << sizeof(A) << endl;//4
    cout << sizeof(B) << endl;//12
    cout << sizeof(C) << endl;//12
    cout << sizeof(D) << endl;//24
}
int main()
{
    Test(); 
    system("pause");    
    return 0;
}

可以看到：
（1）虚基类并不是在声明基类时声明的，而是在声明派生类时，指定继承方式时声明的。
（2）A已经被声明为虚基类了，但是通过测试可以看到D所占字节数为24，在普通继承中，D占20个字节，那多出来的4个字节是什么呢？
通过调试，查看内存以及反汇编得到了答案~

可以看出， 图中解决二义性在VS环境下使用的是偏移量表格，不是直接的指针指向~
（3）虚拟继承的构造函数调用方式为：
派生类–>合成构造函数–>将偏移量表格地址放在对象的前4个字节中
（4）虚拟继承对于继承成员访问形式：
偏移量表格地址–>偏移量表格–>相对于基类对象的偏移量–>访问基类成员