初识C++之继承

1、何为继承

　　C++中所谓继承，就是在一个已存在类的基础上创建一个新的类，新类获得已存在类的部分特性（为什么是部分特性，后面会讲到）。已存在类被称为基类（Base Class）或父类（Father Class），新建类被称为派生类（Derived Class）或子类（Son Class）。
这里写图片描述
继承的声明形式：
class 派生类名:[继承方式] 基类列表
{
　　派生类增加的特性；
}

2、分类

继承在C++中有单继承与多继承的分类。
单继承：派生类有且只有一个基类
多继承：派生类两个或两个以上的基类
文字描述不过瘾，给出声明方法、模型及实例：
①简单的单继承声明方法、模型及实例：

class 派生类名:[继承方式] 基类名
{
　　派生类增加的特性；
}
这里写图片描述

class Base           //父类/基类
{void Fun(){cout << "Base" << endl;}
protected:int data;
};class Derived1: public Base   //子类1/派生类1
{void Fun(){cout << "Derived1" << endl;}
private:int _data;
};class Derived2: public Base   //子类2/派生类2
{void Fun(){cout << "Derived2" << endl;}
private:int _data;
};

②简单的多继承声明方法、模型及实例：

class 派生类名:[继承方式] 基类列表
{
　　派生类增加的特性；
}
这里写图片描述

class Base1
{void Fun(){cout << "Base" << endl;}
protected:int data1;
};class Base2
{void Fun(){cout << "Base" << endl;}
protected:int data2;
};class Derived: public Base1, public Base2
{void Fun(){cout << "Derived" << endl;}
private:int _data;
};

3、继承方式

先来回忆一下继承的声明形式：
class 派生类名:[继承方式] 基类列表
{
　　派生类增加的特性；
}
　　其中，继承方式分为共有（public）、私有（private）、保护（protected）之分，不同的继承方式会产生不同的继承效果（class默认继承方式是私有，struct默认继承方式是公有，但最好还是显示给出继承方式，这样会使程序更加清晰）。
　　
继承方式的区别：
public：基类的非私有成员在派生类中的访问属性不变，基类的私有属性在派生类中存在但不可见。
protected：基类的非私有成员都称为派生类中的保护成员，基类的私有属性在派生类中存在但不可见。
private：基类的非私有成员都称为派生类中的私有成员，基类的私有属性在派生类中存在但不可见。
以上就是为什么说只是基类的部分特性在派生类中可见。

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;class Base
{
public:Base(){}~Base(){}void ShowBase(){cout << "ShowBase" << endl;cout << "pri = " << pri << endl;cout << "pro = " << pro << endl;cout << "pub = " << pub << endl;}private:int pri;
protected:int pro;
public:int pub;
};class Derived :public Base
{
public:Derived(){}~Derived(){}void ShowDerived(){cout << "ShowDerived" << endl;cout << "_pri = " << _pri << endl;cout << "_pro = " << _pro << endl;cout << "_pub = " << _pub << endl;}private:int _pri;
protected:int _pro;
public:int _pub;
};int main()
{Base b;Derived d;b.ShowBase();d.ShowBase(); d.ShowDerived();cout << sizeof(Base) << endl;cout << sizeof(Derived) << endl;return 0;
}

输出结果：
这里写图片描述
对以上输出结果分析：
①为什么ShowBase会被调用两次
　　ShowBase函数被调用了两次，是因为在Derived类中，继承有ShowBase函数，因为该函数在Base类中的属性是public，而且Derived类是以public方式继承自Base类的，所以该函数在Derived类中的属性仍为public，那么它就可以在类外被调用。
②为什么两个类的大小不同
　　从输出结果中很明显的看到，Base类的大小为12，Derived类的大小为2。Base类的大小为12很好理解，因为它里面只有三个成员变量，且都为int类型，但为什么Derived是24呢，这就要牵扯到了继承方式特性，不管继承方式是什么，基类的成员变量的访问限定符是什么，基类的成员变量在派生类中都是存在的，只是有可见与不可见之分。
当我把继承方式修改为protected和private时，程序编译出错：
这里写图片描述

这里写图片描述
这就印证了我们上述的继承方式的特性，因为protected继承方式会把Base类中public访问限定符的BaseShow函数在Derived类中降级为protected访问限定符，同样，private继承方式会把Base类中public访问限定符的BaseShow函数在Derived类中降级为private访问限定符，而protected访问限定符和private访问限定符修饰的内容在类外是不可见的，强行调用肯定会报错，所以这儿会出现错误。

继承方式的特性：
①基类的private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
②不管是哪种继承方式，在派生类内部都可以访问基类的公有成员和保护成员，基类的私有成员存在但是在子类中不可见（不能访问）。
③使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

4、继承关系中构造函数和析构函数的调用
先给出一个例子来剖析：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;class Base
{
public:Base(){cout << "Base()" << endl;}~Base(){cout << "~Base()" << endl;}private:int pri;
protected:int pro;
public:int pub;
};class Derived :protected Base
{
public:Derived(){cout << "Derived()" << endl;}~Derived(){cout << "~Derived()" << endl;}private:int _pri;
protected:int _pro;
public:int _pub;
};int main()
{Base b;Derived d;return 0;
}

这里写图片描述

可以看到在派生类创建对象时，是先调用基类的构造函数，然后在代用自己的构造函数，对于析构函数就很好解释了，可以理解为栈的特性，先进后出。

5、继承关系的作用域
在C++的继承体系中，基类和派生类是属于两个不同作用域。当基类和派生类中有同名成员时，派生类成员将屏蔽基类对成员的直接访问（在派生类成员函数中，可以使用基类名::基类成员来访问基类的同名成员），这就是所谓的同名隐藏，在派生类中的同名成员称为对基类同名成员的重定义。当然，实际中在继承体系里面最好不要定义同名的成员。
注意：因为基类和派生类是属于两个不同作用域，所以两个类中的同名函数不会构成函数重载。

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;class Base
{
public:Base(int _pub = 0, int _pri = 1, int _pro = 2): pub(_pub), pri(_pri), pro(_pro){}~Base(){}void Display(){cout << "Base::Display" << endl;cout << "pub = " << pub << endl;cout << "pri = " << pri << endl;cout << "pro = " << pro << endl;}
public:int pub;
private:int pri;
protected:int pro;
};class Derived: public Base
{
public:Derived(int _pub = 0, int _pri = 1, int _pro = 2): pub(_pub), pri(_pri), pro(_pro){}~Derived(){}void Display(){cout << "Derived::Display" << endl;cout << "pub = " << pub << endl;cout << "pri = " << pri << endl;cout << "pro = " << pro << endl;}
public:int pub;
private:int pri;
protected:int pro;
};int main()
{Base b(1, 2, 3);Derived d(4, 5, 6);b.Display();d.Display();return 0;
}

这里写图片描述

根据上面例子的输出就可以看出来。

6、基类对象与派生类对象的赋值关系

①子类对象可以赋值给父类对象

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;class Base
{
public:Base(int bpub = 5, int bpri = 10, int bpro = 15): pub(bpub), pri(bpri), pro(bpro){}~Base(){}void Display(){cout << "Base::Display" << endl;cout << "pub = " << pub << endl;cout << "pri = " << pri << endl;cout << "pro = " << pro << endl;}public:int pub;
private:int pri;
protected:int pro;
};class Derived: public Base
{
public:Derived(int _dpub = 10, int _dpri = 20, int _dpro = 30): _pub(_dpub), _pri(_dpri), _pro(_dpro){}~Derived(){}void Display(){cout << "Derived::Display" << endl;cout << "_pub = " << _pub << endl;cout << "_pri = " << _pri << endl;cout << "_pro = " << _pro << endl;}public:int _pub;
private:int _pri;
protected:int _pro;
};int main()
{Base b(1, 2, 3);Derived d(4, 5, 6);b = d;b.Display();d.Display();return 0;
}

输出结果：
这里写图片描述
程序可以正常输出，但有些人可能会奇怪，为什么b里面存的是5、10、15，而不是4、5、6，其实原因很简单：

②父类对象不能赋值给子类对象
当我把上例中的“b = d;”换成“d = b;”时，编译器会报错：

还是像刚才那样分析：
这里写图片描述
③父类的指针/引用可以指向子类对象，但是无法使用不存在于基类只存在于派生类的元素。

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;class Base
{
public:Base(int bpub = 5, int bpri = 10, int bpro = 15): pub(bpub), pri(bpri), pro(bpro){}~Base(){}void Display(){cout << "Base::Display" << endl;cout << "pub = " << pub << endl;cout << "pri = " << pri << endl;cout << "pro = " << pro << endl;}public:int pub;
private:int pri;
protected:int pro;
};class Derived: public Base
{
public:Derived(int _dpub = 10, int _dpri = 20, int _dpro = 30): _pub(_dpub), _pri(_dpri), _pro(_dpro){}~Derived(){}void Display(){cout << "Derived::Display" << endl;cout << "_pub = " << _pub << endl;cout << "_pri = " << _pri << endl;cout << "_pro = " << _pro << endl;}public:int _pub;
private:int _pri;
protected:int _pro;
};int main()
{Derived d(4, 5, 6);Base *b = &d;b->Display();return 0;
}

输出结果：
这里写图片描述
上分析图：

④子类的指针/引用不能指向父类对象（可以通过强制类型转换完成）
我把上例中的

int main()
{Derived d(4, 5, 6);Base *b = &d;b->Display();return 0;
}

换成

int main()
{Base b(4, 5, 6);Derived *d = &b;d->Display();return 0;
}

程序会报错：
这里写图片描述
继续上图分析：

7、友元与继承
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。

8、继承与静态成员
基类定义了static成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;class Base
{
public:Base(int bpub = 5, int bsta = 0, int bpri = 10, int bpro = 15): pub(bpub), pri(bpri), pro(bpro){}~Base(){}void Display(){cout << "Base::Display" << endl;cout << "sta = " << sta << endl;}public:int pub;static int sta;
private:int pri;
protected:int pro;
};class Derived: public Base
{
public:Derived(int _dpub = 10, int _dpri = 20, int _dpro = 30): _pub(_dpub), _pri(_dpri), _pro(_dpro){}~Derived(){}void Display(){cout << "Derived::Display" << endl;cout << "sta = " << sta << endl;}public:int _pub;
private:int _pri;
protected:int _pro;
};int Base::sta = 10;int main()
{Base b;Derived d;b.Display();d.Display();return 0;
}