C++之三大特性 “封装”、“继承”、“多态”
目录
封装什么是封装封装的好处
继承继承的概念及定义基类和派生类对象赋值转换继承中的作用域派生类的默认成员函数继承与友元继承与静态成员复杂的菱形继承及菱形虚拟继承继承的总结和反思
多态多态的概念多态的定义及实现虚函数虚函数重写重载、重写（覆盖）、重定义（隐藏）的对比
抽象类多态的原理虚函数表多态的构成条件
封装
什么是封装
C++是基于面向对象的程序，面向对象有三大特性即：封装、继承、多态。
C++通过类，将一个对象的属性与行为结合在一起，使其更符合人们对于一件事物的认知，将属于该对象的所有东西打包在一起；通过访问限定符选择性的将其部分功能开放出来与其他对象进行交互，而对于对象内部的一些实现细节，外部用户不需要知道。
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装的好处
下面举个例子来让大家更好的理解封装性带来的好处，比如：乘火车出行
我们来看下火车站： 售票系统：负责售票----用户凭票进入，对号入座 工作人员：售票、咨询、安检、保全、卫生等 火车：带用户到目的地
火车站中所有工作人员配合起来，才能让大家坐车有条不紊的进行，不需要知道火车的构造，票务系统是如何操作的，只要能正常方便的应用即可。
想想下，如果是没有任何管理的开放性站台呢？ 火车站没有围墙，站内火车管理调度也是随意，乘车也没有规矩，比如：
我们如何管理兵马俑呢？如果什么都不管，兵马俑就被随意破坏了。那么我们首先建了一座房子把兵马俑给封装起来。但是我们目的全封装起来，不让别人破坏。所以我们开放了售票通道，可以买票突破封装在合理的监管机制下进去参观。
类也是一样，我们使用类数据和方法都封装到一下。不想给别人看到的，我们使用protected/private把成员封装起来。开放一些共有的成员函数对成员合理的访问。所以封装本质是一种管理。
继承
继承的概念及定义
继承的概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student和 Teacher复用了Person的成员。
继承定义 定义格式
下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。 继承关系和访问限定符 继承基类成员访问方式的变化 总结：
基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
基类和派生类对象赋值转换
派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。基类对象不能赋值给派生类对象
class Person
{
protected :
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public :
int _No ; // 学号
};
void Test ()
{
Student sobj ;
// 1.子类对象可以赋值给父类对象/指针/引用
Person pobj = sobj ;
Person* pp = &sobj;
Person& rp = sobj;
//2.基类对象不能赋值给派生类对象,下面错误
sobj = pobj;
}
继承中的作用域
在继承体系中基类和派生类都有独立的作用域。
子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
注意在实际中在继承体系里面最好不要定义同名的成员。
隐藏：基类和子类中有相同的成员函数和成员变量，将构成隐藏，也叫重定义。
// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
protected :
string _name = "小李子"; // 姓名
int _num = 111; // 身份证号
};
class Student : public Person
{
public:
void Print()
{
cout<<" 姓名:"<<_name<< endl;
cout<<" 身份证号:"< cout<<" 学号:"<<_num< } protected: int _num = 999; // 学号 }; B中的fun和A中的fun不是构成重载，因为不是在同一作用域 B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。 // B中的fun和A中的fun不是构成重载，因为不是在同一作用域 // B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。 class A { public: void fun() { cout << "func()" << endl; } }; class B : public A { public: void fun(int i) { A::fun(); cout << "func(int i)->" < } }; void Test() { B b; b.fun(10); }; 派生类的默认成员函数 6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？ 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。 派生类的operator=必须要调用基类的operator=完成基类的复制。 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。 派生类对象初始化先调用基类构造再调派生类构造。 派生类对象析构清理先调用派生类析构再调基类的析构 class Person { public : Person(const char* name = "peter") : _name(name ) { cout<<"Person()" < } Person(const Person& p) : _name(p._name) { cout<<"Person(const Person& p)" < } Person& operator=(const Person& p ) { cout<<"Person operator=(const Person& p)"<< endl; if (this != &p) _name = p ._name; return *this ; } ~Person() { cout<<"~Person()" < } protected : string _name ; // 姓名 }; class Student : public Person { public : Student(const char* name, int num) : Person(name ) , _num(num ) { cout<<"Student()" < } Student(const Student& s) : Person(s) , _num(s ._num) { cout<<"Student(const Student& s)" < } Student& operator = (const Student& s ) { cout<<"Student& operator= (const Student& s)"<< endl; if (this != &s) { Person::operator =(s); _num = s ._num; } return *this ; } ~Student() { cout<<"~Student()" < } protected : int _num ; //学号 }; 继承与友元 友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员 继承与静态成员 基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一 个static成员实例 。 class Person { public : Person () {++ _count ;} protected : string _name ; // 姓名 public : static int _count; // 统计人的个数。 }; int Person :: _count = 0; class Student : public Person { protected : int _stuNum ; // 学号 }; class Graduate : public Student { protected : string _seminarCourse ; // 研究科目 }; void TestPerson() { Student s1 ; Student s2 ; Student s3 ; Graduate s4 ; cout <<" 人数 :"<< Person ::_count << endl; Student ::_count = 0; cout <<" 人数 :"<< Person ::_count << endl; } 复杂的菱形继承及菱形虚拟继承 单继承：一个子类只有一个直接父类时称这个继承关系为单继承 多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承 菱形继承：菱形继承是多继承的一种特殊情况。 菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份 如何解决菱形继承中数据冗余和二义性问题 虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承 Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。 class Person { public : string _name ; // 姓名 }; class Student : virtual public Person { protected : int _num ; //学号 }; class Teacher : virtual public Person { protected : int _id ; // 职工编号 }; class Assistant : public Student, public Teacher { protected : string _majorCourse ; // 主修课程 }; void Test () { Assistant a ; a._name = "peter"; } 虚拟继承解决数据冗余和二义性的原理 为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成员的模型。 class A { public: int _a; }; // class B : public A class B : virtual public A { public: int _b; }; // class C : public A class C : virtual public A { public: int _c; }; class D : public B, public C { public: int _d; }; int main() { D d; d.B::_a = 1; d.C::_a = 2; d._b = 3; d._c = 4; d._d = 5; return 0; } 继承的总结和反思 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出菱形继承。否则在复杂度及性能上都有问题。 多继承可以认为是C++的缺陷之一，很多后来的语言都没有多继承，如Java。 多态 多态的概念 多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态和结果。 举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。：同样是买票动作，不同的人买不一样的票，这也是一种多态行为。 多态的定义及实现 多态：函数调用的多种形态 静态多态：函数重载 动态的多态：父类/基类的指针或引用调用重写虚函数 1、父类指针或者引用指向父类，调用的就是父类的虚函数 2、父类指针或者引用指向子类，调用的就是子类的虚函数 多态的构成条件 多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。 Person对象买票全价，Student对象买票半价。 那么在继承中要构成多态还有两个条件： 必须通过基类的指针或者引用调用虚函数被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写 虚函数 虚函数：即被virtual修饰的类成员函数称为虚函数。 虚函数重写 虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。 虚函数重写的两个例外： 协变(基类与派生类虚函数返回值类型不同) 派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。 析构函数的重写(基类与派生类析构函数的名字不同) 如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。 3.子类的虚函数不加virtual也算是完成了重写 #include using namespace std; class Person { public: virtual void BuyTicket() { cout << "买票-全价" << endl; } }; class Student : public Person { public: // 子类的虚函数重写了父类的虚函数 virtual void BuyTicket() { cout << "买票-半价" << endl; } }; class Soldier : public Person { public: // 子类的虚函数重写了父类的虚函数 virtual void BuyTicket() { cout << "优先-买票" << endl; } }; void f(Person& p) { // 传不同类型的对象，调用的是不同的函数，实现了调用的多种形态 p.BuyTicket(); } int main() { Person p; // 普通人 Student st; // 学生 Soldier so; // 军人 f(p); f(st); f(so); return 0; } 重载、重写（覆盖）、重定义（隐藏）的对比 抽象类 概念 在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类 不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。 多态的原理 虚函数表 先看一道题 // 这里常考一道笔试题：sizeof(Base)是多少？ class Base { public: virtual void Func1() { cout << "Func1()" << endl; } private: int _b = 1; }; int main() { Base b; return 0; } 大家会不会以为是4，但结果是8，有没有出乎意料呢？ 通过监视窗口，我们发现b对象是8bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。那么派生类中这个表放了些什么呢？我们接着往下分析 // 针对上面的代码我们做出以下改造 // 1.我们增加一个派生类Derive去继承Base // 2.Derive中重写Func1 // 3.Base再增加一个虚函数Func2和一个普通函数Func3 class Base { public: virtual void Func1() { cout << "Base::Func1()" << endl; } virtual void Func2() { cout << "Base::Func2()" << endl; } void Func3() { cout << "Base::Func3()" << endl; } private: int _b = 1; }; class Derive : public Base { public: virtual void Func1() { cout << "Derive::Func1()" << endl; } private: int _d = 2; }; int main() { Base b; Derive d; return 0; } 通过观察和测试，我们发现了以下几点问题： 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。 虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。 这里还有一个童鞋们很容易混淆的问题：虚函数存在哪的？ 注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。 虚表存在哪的？ 多态的构成条件 多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。 Person对象买票全价，Student对象买票半价。 那么在继承中要构成多态还有两个条件： 必须通过基类的指针或者引用调用虚函数被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写 问为什么一定要基类的指针或者引用去调用虚函数才能达到多态呢？基类对象直接调用虚函数不行吗？ 由测试结果可知，只有基类的指针或者引用去调用虚函数才可以达到多态，基类的对象不能达到多态。