目录

继承：

继承的概念：

继承的定义：

 基类和派生类对象赋值转换 ：

继承中的作用域：

派生类的默认成员函数：

例题：

​编辑​编辑​编辑

继承与友元：

 继承与静态成员：

复杂的菱形继承及菱形虚拟继承：

继承与组合：

多态：

1. 多态的概念：

2. 多态的定义及实现：

多态的构成条件 ：

虚函数重写的一些其他问题：

override 和 final 关键字：

重载、覆盖(重写)、隐藏(重定义)的对比:

纯虚函数和抽象类：

多态的原理 ：

继承：

1.继承的概念：

class Person
   {
public:
 void Print()
     {
         cout << "name:" << _name << endl;
         cout << "age:" << _age << endl;
     }
protected:
     string _name = "peter"; // 姓名
     int _age = 18;  // 年龄
};


// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了
Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可
以看到变量的复用。调用Print可以看到成员函数的复用。


class Student : public Person
{
protected:
     int _stuid; // 学号
};


class Teacher : public Person
{
protected:
     int _jobid; // 工号
};


int main()
{
 Student s;
 Teacher t;
 s.Print();
 t.Print();
 return 0;
}

2.继承的定义：

        定义格式：

Person 是父类，也称作基类。 Student 是子类，也称作派生类。

         继承关系和访问限定符：

         继承基类成员访问方式的变化 ：

类成员 / 继承方式	public 继承	protected 继承	private 继承
基类的 public 成员	派生类的 public 成员	派生类的 protected 成员	派生类的 private 成员
基类的 protected 成员	派生类的 protected 成员	派生类的 protected 成员	派生类的 private 成员
基类的 private 成 员	在派生类中不可见	在派生类中不可见	在派生类中不可 见

         总结：

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私 有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面 都不能去访问它。
2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在 派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他 成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡 使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里 面使用，实际中扩展维护性不强

3.基类和派生类对象赋值转换 ：

        过度设计：

、

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;
    
    // 3.基类的指针可以通过强制类型转换赋值给派生类的指针
    pp = &sobj
    Student* ps1 = (Student*)pp; // 这种情况转换时可以的。
    ps1->_No = 10;
    
    pp = &pobj;
    Student* ps2 = (Student*)pp;  //这种情况转换时虽然可以，但是会存在越界访问的问题

    ps2->_No = 10;
}

class Student;

class Person
{
public:
     friend void Display(const Person& p, const Student& s);
protected:
     string _name; // 姓名
};

class Student : public Person
{
protected:
     int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
     cout << p._name << endl;
     cout << s._stuNum << endl;
}

void main()
{
     Person p;
     Student s;
     Display(p, s);
}

8. 继承与静态成员：

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;
}

---

9.复杂的菱形继承及菱形虚拟继承：

单继承 ：

一个子类只有一个直接父类时称这个继承关系为单继承

多继承：

一个子类有两个或以上直接父类时称这个继承关系为多继承

菱形继承 ：

菱形继承是多继承的一种特殊情况。

从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。

在Assistant的对象中Person成员会有两份。

10.继承与组合：

• public继承是一种is-a的关系。也就是说每个子类对象都是一个父类对象。
• 组合是一种has-a的关系。假设B组合了A,每个B对象中都有一个A对象。
• 继承允许你根据父类的实现来定义子类的实现。这种通过生成子类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言:在继承方式中,父类的内部细节对子类可见。继承一定程度破坏了父类的封装,父类的改变,对子类有很大的影响。子类和父类间的依赖关系很强,耦合度高。
• 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse),因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系,耦合度低。优先使用对象组合有助于你保持每个类被封装。
• 优先使用组合,而不是继承。实际尽量多去用组合,组合的耦合度低,代码维护性好。不过也不太那么绝对,类之间的关系就适合继承(is-a)那就用继承,另外要实现多态,也必须要继承。类之间的关系既适合用继承(is-a)也适合组合(has-a),就用组合。
• 很多人说C++语法复杂,其实多继承就是一个体现。有了多继承,就存在菱形继承,有了菱形继承就有菱形虚拟继承,底层实现就很复杂,性能也会有一些损失,所以最好不要设计出菱形继承。多继承可以认为是C++的缺陷之一,后来的一些编程语言都没有多继承,如Java。

多态：

1. 多态的概念：

多态的概念：通俗来说，就是多种形态， 具体点就是去完成某个行为，当不同的对象去完成时会

产生出不同的状态 。

多态(polymorphism)的概念:通俗来说,就是多种形态。多态分为编译时多态(静态多态)和运行时多
态(动态多态),这里我们重点讲运行时多态,编译时多态(静态多态)和运行时多态(动态多态)。编译时
多态(静态多态)主要就是我们前面讲的函数重载和函数模板,他们传不同类型的参数就可以调用不同的函数,通过参数不同达到多种形态,之所以叫编译时多态,是因为他们实参传给形参的参数匹配是在
编译时完成的,我们把编译时一般归为静态,运行时归为动态。

运行时多态,具体点就是去完成某个行为(函数),可以传不同的对象就会完成不同的行为,就达到多种
形态。比如实票这个行为,当普通人买票时,是全价买票;学生买票时,是优惠买票(5折或75折);军人买票时是优先买票。再比如,同样是动物叫的一个行为(函数),传猫对象过去,就是”(>^ω^<)喵“,传狗对象过去,就是“汪汪”。

---

2. 多态的定义及实现：

多态的构成条件 ：

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如 Student 继承了

Person 。 Person 对象买票全价， Student 对象买票半价。

那么在继承中要 构成多态还有两个条件 ：

• 必须通过基类的指针或者引用调用虚函数
• 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

虚函数：

即被 virtual 修饰的类成员函数称为虚函数，非成员函数不能加virtual修饰.

说明:

要实现多态效果,第一必须是基类的指针或引用,因为只有基类的指针或引用才能既指向派生类对象;第二派生类必须对基类的虚函数重写/覆盖,重写或者覆盖了,派生类才能有不同的函数,多态的不同形态效果才能达到。

虚函数的重写/覆盖:

派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同),称派生类的虚函数重写了基类的虚函数。

注意:

在重写基类虚函数时,派生类的虚函数在不加virtual关键字时,虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范,不建议这样使用不过在考试选择题中,经常会故意埋这个坑,让你判断是否构成多态。

例题：

！！！！！！！不要对继承来的缺省值做变 ！！！！！！！！！ 

（没记错的话在Effective C++的180左右有讲过）

3.虚函数重写的一些其他问题：

1. 协变(了解)：

派生类重写基类虚函数时,与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或引用,派生类虚函数返回派生类对象的指针或者引用时,称为协变。协变的实际意义并不大,所以我们了解一下即可。

2. 析构函数的重写：

基类的析构函数为虚函数,此时派生类析构函数只要定义,无论是否加virtual关键字,都与基类的析构函数构成重写,虽然基类与派生类析构函数名字不同看起来不符合重写的规则,实际上编译器对析构函数的名称做了特殊处理,编译后析构函数的名称统一处理成destructor,所以基类的析构函数加了vialtual修饰,派生类的析构函数就构成重写。

下面的代码我们可以看到,如果~A(),不加virtual,那么delete p2时只调用的A的析构函数,没有调用
B的析构函数,就会导致内存泄漏问题,因为~B()中在释放资源。

class A
{
public:
	virtual ~A()
	{
		cout << "~A()" << endl;
	}
};

class B : public A {
public:
	// 构成重写
	~B()
	{
		cout << "~B()->delete:" << _p << endl;
		delete _p;
	}
protected:
	int* _p = new int[10];
};

int main()
{
    A* p1 = new A;
    A* p2 = new B;

    // p1->destructor() + operator delete
    delete p1;
    delete p2;

    return 0;
}

注意:

这个问题面试中经常考察,要结合类似上面的样例才能讲清楚,为什么基类中的析构函数建议设计为虚函数。

4.override 和 final 关键字：

从上面可以看出,C++对虚函数重写的要求比较严格,但是有些情况下由于疏忽,比如函数名写错参数写重写错等导致无法构成重写,而这种错误在编译期间是不会报出的,只有在程序运行时没有得到预期结果才来debug会得不偿失,因此C++11提供了override,可以帮助用户检测是否重写。如果我们不想让派生类重写这个虚函数,那么可以用final去修饰。

class Car
{
public:
    virtual void Drive(){}
}; 

class Benz :public Car 
{
public:
    virtual void Drive() override {cout << "Benz-舒适" << endl;}
};

class Car
{
public:
     virtual void Drive(){}
};

class Benz :public Car 
{
public:
     virtual void Drive() override {cout << "Benz-舒适" << endl;}
};

6.纯虚函数和抽象类：

虚函数表

• 基类对象的虚函数表中存放基类所有虚函数的地址。
• 派⽣类由两部分构成，继承下来的基类和⾃⼰的成员，⼀般情况下，继承下来的基类中有虚函数表 指针，⾃⼰就不会再⽣成虚函数表指针。但是要注意的这⾥继承下来的基类部分虚函数表指针和基 类对象的虚函数表指针不是同⼀个，就像基类对象的成员和派⽣类对象中的基类对象成员也独⽴的。
• 派⽣类中重写的基类的虚函数，派⽣类的虚函数表中对应的虚函数就会被覆盖成派⽣类重写的函数地址。
• 派⽣类的虚函数表中包含，基类的虚函数地址，派⽣类重写的虚函数地址，派⽣类⾃⼰的虚函数地 址三个部分。
• 虚函数表本质是⼀个存虚函数指针的指针数组，⼀般情况这个数组最后⾯放了⼀个0x0000000标 记。(这个C++并没有进⾏规定，各个编译器⾃⾏定义的，vs系列编译器会再后⾯放个0x00000000 标记，g++系列编译不会放)
• 虚函数存在哪的？虚函数和普通函数⼀样的，编译好后是⼀段指令，都是存在代码段的，只是虚函数的地址⼜存到了虚表中。
• 虚函数表存在哪的？这个问题严格说并没有标准答案C++标准并没有规定，我们写下⾯的代码以对⽐验证⼀下。vs下是存在代码段(常量区)

8.同类型对象虚表共用,不同类型对象虚表各自独立：