知识点1【继承和派生的概述】
继承的优点:减少代码的冗余,提高代码的重用性
知识点2【继承的格式】
派生类定义格式:
class 派生类名:继承方式 基类名{
//派生类新增的数据成员和成员函数
};
继承方式分类:
public:公有继承(重要)
private:私有继承
protected:保护继承
父类个数分类:
单继承:指每个派生类只直接继承了一个基类的特征(一个父类派生出一个子类)。
class Derived : public BaseA
{
};
多继承:一个子类可以有多个父类,子类拥有所有父类的成员变量,子类继承所有父类的成员函数,子类对象可以当作任意父类对象使用。
class Derived : public BaseA, public BaseB, public BaseC
{
};
注意:子类继承父类,子类拥有父类中全部成员变量和成员方法(除了构造和析构函数之外的成员方法),但是在子类中,继承的成员并不一定能直接访问,不同的继承方式会导致不同的访问权限。
案例1:公有继承(public)
#include <iostream>
using namespace std;
class Base{
private:
int B_a;
protected:
int B_b;
public:
int B_c;
};
class Son:public Base{
//父类中的public数据 在子类中 也是public
//父类中的private数据 在子类中 是不可见的
//父类中的protected数据 在子类中 是protected的
public:
void func(){
B_b = 100;
//B_a = 300;在子类中private数据,不可见
B_c = 300;//在子类中内部protected数据,可以直接访问
}
};
int main(int argc, char *argv[])
{
Base *base = new Son();//注意:B PRIVATE/protected 继承A,那么 A 的指针不能指向B
//base->B_b;//protected数据 在子类外是访问不了的
//base->B_b;//protected数据 在子类外是访问不了的
base->B_c;
//base->B_a;//private数据在子类外是访问不了的
cout << "Hello World!" << endl;
return 0;
}
案例2:保护继承(protected)
#include <iostream>
using namespace std;
class Base{
private:
int B_a;
protected:
int B_b;
public:
int B_c;
};
class Son:protected Base{
//父类中的public数据 在子类中 是protected
//父类中的private数据 在子类中 是不可见的
//父类中的protected数据 在子类中 是protected的
public:
void func(){
B_b = 100;
//B_a = 300;在子类中private数据,不可见
B_c = 300;//在子类中内部protected数据,可以直接访问
}
};
int main(int argc, char *argv[])
{
Son *base = new Son();
//base->B_b;//protected数据 在子类外是访问不了的
//base->B_c;//public数据 在子类外是访问不了的
//base->B_a;//private数据在子类外是访问不了的
cout << "Hello World!" << endl;
return 0;
}
案例3:私有继承(private)
#include <iostream>
using namespace std;
class Base{
private:
int B_a;
protected:
int B_b;
public:
int B_c;
};
class Son:private Base{
//父类中的public数据 在子类中 是private
//父类中的private数据 在子类中 是不可见的
//父类中的protected数据 在子类中 是private
public:
void func(){
B_b = 100;
//B_a = 300;在子类中private数据,不可见
B_c = 300;//在子类中内部protected数据,可以直接访问
}
};
int main(int argc, char *argv[])
{
Son *base = new Son();//注意:B PRIVATE/protected 继承A,那么 A 的指针不能指向B
//base->B_b;//protected数据 在子类外是访问不了的
//base->B_c;//public数据 在子类外是访问不了的
//base->B_a;//private数据在子类外是访问不了的
cout << "Hello World!" << endl;
return 0;
}
总结:
知识点3【继承中的构造和析构的顺序】
#include <iostream>
using namespace std;
class Base{
private:
int B_a;
protected:
int B_b;
public:
int B_c;
Base(){
cout << "父类的无参构造" << endl;
}
~Base(){
cout << "父类的析构函数" << endl;
}
};
class Son:private Base{
public:
Son(){
cout << "子类的构造函数" << endl;
}
~Son(){
cout << "子类的析构函数" << endl;
}
};
int main(int argc, char *argv[])
{
Son *base = new Son();
delete base;
return 0;
}
运行结果:
总结:
构造顺序:父类(基类)构造------->子类(派生类)构造
析构顺序:子类(派生类)---------> 父类(基类)析构
知识点4【子类中有父类、对象成员,构造和析构的顺序】
#include <iostream>
using namespace std;
class Other{
public:
int O_a;
Other(){
cout << "对象的无参构造" << endl;
}
~Other(){
cout << "对象的析构函数" << endl;
}
};
class Base{
private:
int B_a;
protected:
int B_b;
public:
int B_c;
Base(){
cout << "父类的无参构造" << endl;
}
~Base(){
cout << "父类的析构函数" << endl;
}
};
class Son:private Base{
private:
Other other;
public:
Son(){
cout << "子类的构造函数" << endl;
}
~Son(){
cout << "子类的析构函数" << endl;
}
};
int main(int argc, char *argv[])
{
Son *base = new Son();
delete base;
return 0;
}
运行结果:
知识点5【详解子类中的构造】
1、子类会默认调用父类的无参构造
2、子类必须显式使用初始化列表调用父类的有参构造
调用形式:父类名称
Son(int a,int b):Base(a),b(b){
}
#include <iostream>
using namespace std;
class Other{
public:
int O_a;
Other(int a){
this->O_a = a;
cout << "对象的无参构造" << endl;
}
~Other(){
cout << "对象的析构函数" << endl;
}
};
class Base{
private:
int B_a;
protected:
int B_b;
public:
int B_c;
Base(int a,int b){
this->B_a = a;
this->B_b = b;
cout << "父类的有参构造" << endl;
}
~Base(){
cout << "父类的析构函数" << endl;
}
};
class Son:public Base{
private:
Other other;
public:
Son(int a,int b, int c):Base(a,b),other(c){
cout << "子类的有参构造" << endl;
cout << this->other.O_a << endl;
cout << this->B_b << endl;
}
~Son(){
cout << "子类的析构函数" << endl;
}
};
int main(int argc, char *argv[])
{
Son *base = new Son(10,20,30);
delete base;
return 0;
}
运行结果:
知识点6【父类和子类的同名成员变量处理】
1、当父类和子类成员变量同名时,在子类就近原则,选择本作用域的子类的成员
2、如果在子类中,必须使用父类中的同名成员,必须加上父类的作用域
#include <iostream>
using namespace std;
class Base{
public:
int num;
Base(int num){
this->num = num;
cout << "父类有参构造" << endl;
}
~Base(){
cout << "父类析构函数" << endl;
}
};
class Son:public Base{
public:
int num;
Son(int num1,int num2):Base(num1),num(num2){
cout << "父类有参构造" << endl;
}
void showNum(){
//当父类和子类成员变量同名时,在子类就近原则,选择本作用域的子类的成员
cout << num << endl;
//如果在子类中 必须使用父类中的同名成员 必须加上父类的作用域
cout << Base::num << endl;
}
~Son(){
cout << "子类析构函数" << endl;
}
};
int main(int argc, char *argv[])
{
Son *son = new Son(100,200);
son->showNum();
delete son;
return 0;
}
运行结果:
3、子类可以借助父类的共有方法间接的操作父类的私有数据(不可见的数据)
#include <iostream>
using namespace std;
class Base{
private:
int num;
public:
Base(int num){
this->num = num;
cout << "父类有参构造" << endl;
}
int getNum(){
return this->num;
}
~Base(){
cout << "父类析构函数" << endl;
}
};
class Son:public Base{
public:
int num;
Son(int num1,int num2):Base(num1),num(num2){
cout << "父类有参构造" << endl;
}
void showNum(){
//当父类和子类成员变量同名时,在子类就近原则,选择本作用域的子类的成员
cout << num << endl;
//如果在子类中 必须使用父类中的private成员 以借助父类的共有方法间接的操作父类的私有数据
cout <<this->getNum()<< endl;
}
~Son(){
cout << "子类析构函数" << endl;
}
};
int main(int argc, char *argv[])
{
Son *son = new Son(100,200);
son->showNum();
delete son;
return 0;
}
知识点7【父类和子类的同名成员函数处理】
#include <iostream>
using namespace std;
class Base1{
private:
int num;
public:
Base(int num){
this->num = num;
cout << "父类有参构造" << endl;
}
int getNum(){
return this->num;
}
~Base1(){
cout << "父类析构函数" << endl;
}
};
class Base{
public:
void func(){
cout << "父类void-func函数" << endl;
}
void func(int a){
cout << "父类a-func函数" << endl;
}
};
class Son:public Base{
public:
void func(int a){
cout << "子类a-func函数" << endl;
}
};
int main(int argc, char *argv[])
{
Son *son = new Son();
son->func(100);
//son->func();//err 一旦子类 实现了 父类的同名成员函数 将屏蔽所有父类同名成员函数
//如果用户 必须要调用父类 的同名成员函数 必须加作用域
son->Base::func();
son->Base::func(200);
delete son;
return 0;
}
运行结果:
知识点8【继承中的静态成员特性】
#include <iostream>
using namespace std;
class Base1{
private:
int num;
public:
Base(int num){
this->num = num;
cout << "父类有参构造" << endl;
}
int getNum(){
return this->num;
}
~Base1(){
cout << "父类析构函数" << endl;
}
};
class Base{
public:
static int num;
static int data;
static void showData(){
cout << "父类静态成员函数" << endl;
}
};
int Base::num = 200;
int Base::data = 100;
class Son:public Base{
public:
static int num;
static void showData(){
cout << "子类静态成员函数" << endl;
}
};
int Son::num = 300;
int main(int argc, char *argv[])
{
Son *son = new Son();
//Son 也拥有了静态成员data
cout<< Son::data << endl;
//父和子类静态成员同名,在子类中访问子类中的成员
cout << Son::num <<endl;
//父和子类 静态成员 同名 访问父类中的成员 必须加 Base::
cout << Son::Base::num <<endl;
//父和子类 同名静态成员函数 子类默认访问子类的静态成员函数
Son::showData();
//父和子类 同名静态成员函数 子类访问父类的静态成员函数 必须加 Base::
Son::Base::showData();
delete son;
return 0;
}
运行结果:
知识点9【多继承】(了解)
多继承的格式:
class 子类:继承方式1 父类名1,继承方式2 父类名2,继承方式3 父类名3,...{
};
//表示子类 是由 父类名1,父类名2,父类名3...共同派生出来
class Base1
{
public:
int a;
};
class Base2
{
public:
int b;
};
class Son:public Base1,public Base2
{
//Son类 拥有了a b
};
int main(int argc, char *argv[])
{
Son ob;
ob.a = 100;
ob.b = 200;
return 0;
}
多继承容易产生二义性:(解决办法1 使用作用域)
class Base1
{
public:
int a;
};
class Base2
{
public:
int a;
};
class Son:public Base1,public Base2
{
//Son类 拥有了a b
};
int main(int argc, char *argv[])
{
Son ob;
ob.a = 100;err Base1 和 Base2中都有a成员同名
//解决办法:加作用域
ob.Base1::a = 100;
ob.Base2::a = 200;
return 0;
}
知识点10【菱形继承】
上述类图中,Teacher类和Student类都会继承People的成员,Doctor会继承Teacher类和Student类的成员,因此Doctor将会有两份继承自顶层父类People的成员。
class Animal
{
public:
int data;
};
class Sheep:public Animal
{
public:
};
class Tuo:public Animal
{
public:
};
class SheepTuo:public Sheep,public Tuo
{
public:
};
int main(int argc, char *argv[])
{
SheepTuo st;
//SheepTuo 从Sheep中继承data 从Tuo继承data 就产生二义性
//st.data = 200;//err
//第一种方式:加作用域解决
st.Sheep::data = 200;
st.Tuo::data = 300;
return 0;
}
普通继承:
class Animal
{
public:
int data;
}
class Sheep:public Animal
{
public:
};
class Tuo:public Animal
{
public:
};
class SheepTuo:public Sheep,public Tuo
{
public:
};
知识点11【虚继承】(了解)
virtual修饰继承方式:
//继承的动作 虚继承
//父类:虚基类
class 子类:virtual public 父类
{
};
class Sheep:virtual public Animal
{
public:
};
vbptr(虚基类指针) 其中v是virtual 虚 b是base 基类 prt指针(vbptr指向虚基类表)
vbtable(虚基类表 ) 保存了当前的虚指针相对于虚基类的首地址的偏移量
class Tuo:virtual public Animal
{
public:
};
总结:之所以 产生 vbptr和vbtable 目的 保证 不管多少个继承 虚基类的数据只有一份。
class SheepTuo:public Sheep,public Tuo
{
public:
};
案例1:
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include<string.h>
using namespace std;
class Animal
{
public:
int data;
};
class Sheep :virtual public Animal
{
public:
};
class Tuo :virtual public Animal
{
public:
};
class SheepTuo :public Sheep, public Tuo
{
public:
};
int main(int argc, char* argv[])
{
SheepTuo 2;
st.data = 200;
//通过Sheep的vbptr 寻找vbptr距离虚基类首地址的偏移量
//&st == vbptr
//*(int *)&st sheep 的虚基类表的起始位置
int off_set = (int)*((int*)(*(int*)&st) + 1);
cout << off_set << endl;
//通过sheep的vbptr 和 off_set定位虚基类的首地址
cout << ((Animal*)((char*)&st + off_set))‐>data << endl;
return 0;
注意: 虚继承只能解决具备公共祖先的多继承所带来的二义性问题,不
能解决没有公共祖先的多继承的。
虚继承:不管继承多少次 虚基类 只有一份数据。
知识点12【多态的概述】
1、概念
多态是c++d的特征之一
多态的分类:静态多态(静态联编)、动态多态(动态联编)
静态多态(静态联编):函数入口地址 是在 编译阶段 确定(运算符重载、函数重载)
动态多态(动态联编):函数入口地址 是在 运行阶段 确定(虚函数)
2、引入
#include <iostream>
using namespace std;
class Animal{
public:
void sleep(void)
{
cout<<"animal 动物在睡觉"<<endl;
}
};
class Cat:public Animal{
public:
void sleep(void)
{
cout<<"cat 喵喵在睡觉"<<endl;
}
};
int main(int argc, char *argv[])
{
//用基类(指针或引用) 保存 子类对象(向上转换)
Animal *ob = new Cat();
ob->sleep();
Animal* &ob1 = ob;
ob1->sleep();
return 0;
}
运行结果:
总结:基类指针、引用只能访问子类对象中,基类部分数据
3、使用基类指针、引用访问子类对象中的成员方法(虚函数)
使用virtual修饰成员函数 该成员函数就是虚函数
class Animal{
public:
virtual void sleep(void)
{
cout<<"animal 动物在睡觉"<<endl;
}
};
vfptr虚函数指针 指向的是虚函数表(vftable)
vftable表存放的是 vfptr做保存的函数入口地址
注意://如果 Animal没有涉及到继承 函数指针变量 就指向自身sleep
class Animal{
public:
//虚函数 本质 是一个函数指针变量
virtual void sleep(void)
{
cout<<"animal 动物在睡觉"<<endl;
}
};
void test01(){
//如果 Animal没有涉及到继承 函数指针变量 就指向自身sleep
Animal ob;
ob.sleep();
}
4、拥有虚函数的类 涉及得到继承
class Cat:public Animal{
public:
virtual void sleep(void)
{
cout<<"cat 喵喵在睡觉"<<endl;
}
};
void test01(){
//如果 Animal没有涉及到继承 函数指针变量 就指向自身sleep
Animal *ob = new Cat();
ob->sleep();
}
总结:当虚函数涉及到继承的时候 子类 会继承 父类的(虚函数指针vfptr 虚函数表vftable),编译器会将虚函数表中的函数入口地址 更新 成子类的 同名(返回值、参数都相同)的函数入口地址。如果基类指针、引用 访问虚函数的时候 就会 间接的调用 子类的虚函数.
5、虚函数的应用案例(基类指针、引用 作为函数的参数)
#include <iostream>
using namespace std;
class Base
{
public:
virtual void sleep(void)
{
cout<<"父亲在睡觉"<<endl;
}
};
class Son1:public Base
{
public:
void sleep(void)
{
cout<<"Son1在安静的睡觉"<<endl;
}
};
class Son2:public Base
{
public:
virtual void sleep(void)
{
cout<<"Son2在轻度的睡觉"<<endl;
}
};
class Son3:public Base
{
public:
virtual void sleep(void)
{
cout<<"Son3在雨声般的睡觉"<<endl;
}
};
class Son4:public Base
{
public:
virtual void sleep(void)
{
cout<<"Son4在鼾声如雷"<<endl;
}
};
//以基类指针作为函数的参数 函数可以操作该基类派生出的任意子类对象
void sleepFun(Base &ob)
{
ob.sleep();
}
int main(int argc, char *argv[])
{
Son1 ob1;
Son2 ob2;
Son3 ob3;
Son4 ob4;
sleepFun(ob1);
sleepFun(ob2);
sleepFun(ob3);
sleepFun(ob4);
return 0;
}
运行结果:
问题:C++的动态捆绑机制是怎么样的?
首先,我们看看编译器如何处理虚函数。当编译器发现我们的类中有虚函数的时候,编译器
会创建一张虚函数表,把虚函数的函数入口地址放到虚函数表中,并且在类中秘密增加一个
指针,这个指针就是vpointer(缩写vptr),这个指针是指向对象的虚函数表。在多态调用的
时候,根据vptr指针,找到虚函数表来实现动态绑定。
知识点13【虚析构】
1、知识点的引入
#include <iostream>
using namespace std;
class Animal{
private:
int name;
int age;
public:
//虚函数 本质函数指针 不涉及继承时 指向自身函数(sleep)
virtual void sleep(){
cout << "动物在睡觉" << endl;
}
Animal(){
cout << "Animal构造函数" << endl;
}
~Animal(){
cout << "Aniaml析构函数" << endl;
}
};
class Cat:public Animal{
public:
//虚函数 设计到继承 指针子类的sleep
virtual void sleep(){
cout << "Cat 在睡觉" << endl;
}
Cat(){
cout << "Cat构造函数" << endl;
}
~Cat(){
cout << "Cat析构函数" << endl;
}
};
int main(int argc, char *argv[])
{
//通过基类 指针、引用 访问子类的成员函数
Animal *ob = new Cat();
ob->sleep();
//出现的问题:只能释放 父类析构
delete ob;
return 0;
}
运行结果:
原因分析:
2、解决上面的问题 虚析构(虚函数)
虚析构:通过基类指针、引用释放子类的所有空间
虚析构:在析构函数前加virtual修饰
#include <iostream>
using namespace std;
class Animal{
private:
int name;
int age;
public:
//虚函数 本质函数指针 不涉及继承时 指向自身函数(sleep)
virtual void sleep(){
cout << "动物在睡觉" << endl;
}
Animal(){
cout << "Animal构造函数" << endl;
}
virtual ~Animal(){
cout << "Aniaml析构函数" << endl;
}
};
class Cat:public Animal{
public:
//虚函数 设计到继承 指针子类的sleep
virtual void sleep(){
cout << "Cat 在睡觉" << endl;
}
Cat(){
cout << "Cat构造函数" << endl;
}
virtual ~Cat(){
cout << "Cat析构函数" << endl;
}
};
int main(int argc, char *argv[])
{
//通过基类 指针、引用 访问子类的成员函数
Animal *ob = new Cat();
ob->sleep();
//如果设置成了 虚析构 就可以释放 子类以及父类的构造函数
delete ob;
return 0;
}
运行结果:
原理分析:
知识点14【纯虚函数和抽象类】
1、纯虚函数和抽象类格式
纯虚函数格式:virtual void sleep(void) = 0;
如果一个类中拥有纯虚函数,那么这个类就是抽象类,抽象类不能实例化对象。
void test02(){
//Animal 抽象类 不能实例化 一个对象
//Animal ob;//err
}
2、 抽象类派生出子类,那么子类必须实现所有的纯虚函数
#include <iostream>
using namespace std;
class Animal{
private:
int name;
int age;
public:
//纯虚函数
//如果一个类中拥有 纯虚函数 那么这个类 就是抽象类
//抽象类 不能实例化对象
virtual void sleep()= 0;
Animal(){
cout << "Animal构造函数" << endl;
}
virtual ~Animal(){
cout << "Aniaml析构函数" << endl;
}
};
class Cat:public Animal{
public:
在子类中 必须实现 基类的纯虚函数
virtual void sleep(){
cout << "Cat 在睡觉" << endl;
}
Cat(){
cout << "Cat构造函数" << endl;
}
virtual ~Cat(){
cout << "Cat析构函数" << endl;
}
};
int main(int argc, char *argv[])
{
//通过基类 指针、引用 访问子类的成员函数
Animal *ob = new Cat();
ob->sleep();
//出现的问题:只能释放 父类析构
delete ob;
return 0;
}
案例:饮料制作
//抽象类 提供一个固定的流程 接口
class AbstractDrinking{
public:
//烧水
virtual void Boil() = 0;
//冲泡
virtual void Brew() = 0;
//倒入杯中
virtual void PourInCup() = 0;
//加入辅料
virtual void PutSomething() = 0;
//规定流程
void MakeDrink(){
Boil();
Brew();
PourInCup();
PutSomething();
}
};
//制作咖啡
class Coffee : public AbstractDrinking{
public:
//烧水
virtual void Boil(){
cout << "煮农夫山泉!" << endl;
}
//冲泡
virtual void Brew(){
cout << "冲泡咖啡!" << endl;
}
//倒入杯中
virtual void PourInCup(){
cout << "将咖啡倒入杯中!" << endl;
}
//加入辅料
virtual void PutSomething(){
cout << "加入牛奶!" << endl;
}
};
//制作茶水
class Tea : public AbstractDrinking{
public:
//烧水
virtual void Boil(){
cout << "煮自来水!" << endl;
}
//冲泡
virtual void Brew(){
cout << "冲泡茶叶!" << endl;
}
//倒入杯中
virtual void PourInCup(){
cout << "将茶水倒入杯中!" << endl;
}
//加入辅料
virtual void PutSomething(){
cout << "加入食盐!" << endl;
}
};
//业务函数
void DoBussiness(AbstractDrinking* drink){
drink->MakeDrink();
delete drink;
}
void test01(){
//制作 咖啡
DoBussiness(new Coffee);
//制作 茶水
DoBussiness(new Tea);
}
int main(int argc, char *argv[])
{
test01();
return 0;
}
`运行结果:
知识点15【纯虚析构】
纯虚函数:不需要实现函数体
//纯虚析构函数
class B{
public:
// 1、virtual修饰 加上=0
//如果为纯虚析构函数,则不能实例化对象
virtual ~B() = 0;
};
//2、必须实现 析构函数的函数体
B::~B(){}
//原因:通过基类指针 释放子类对象时 先调用子类析构 再父类析构(如果父类的析构不实现,无法实现调用)
知识点15【虚函数 纯虚函数 虚析构 纯虚析构】(重要)
1、虚函数:只有virtual修饰函数体(作用于成员函数)
目的:通过基类指针或引用操作子类方法
class Base{
public:
virtual void my_fun(){
//有函数体
}
};
2、纯虚函数:virtual修饰,加=0,没有函数,所在的类为抽象类
目的:为子类提供固定的流程和接口
class Base{
public:
virtual my_fun(void)=0;
}
3、虚析构:virtual修饰,类中的析构函数
目的:为了解决基类的指针派生类对象,并用基类的指针删除派生类对象。
class Base{
public:
virtual ~Base(){
//有函数体
}
}
4、纯虚析构:virtual修饰加=0,必须实现析构的函数体
目的:用基类的指针删除派生类对象、同时提供固定接口
class Base
{
public:
virtual ~Base()=0;
}
Base::~Base(){
//函数体
}
知识点16【重写 重载 重定义】
1、重载
同一作用域的同名函数、参数个数、参数顺序、参数类型不同(和函数返回值没有关系)
const也可以作为重载条件
int fun(int a){}
int fun(int b,int c){}
int fun(char b,int c){}
int fun(const char b,int c){}
2、重定义(隐藏)
有继承
子类(派生类)重写父类(基类)的同名成员。(非virtual函数)
class Base{
public:
void fun(int){}
void fun(int,int){}
}
class Son:public Base{
public:
//当派生类重新定义函数时,参数可以不同
void fun(){}//重定义
}
3、重写(覆盖)
有继承
子类(派生类)重写父类(基类)的virtual的函数。
函数返回值,函数名字,函数参数,必须和基类中的虚函数一致。
class Base{
public:
virtual void fun(int){}
}
class Son:public Base{
public:
virtual void fun(int){}//重写
}