【C++核心】面向对象的三大特性

面向对象的三大特性

  • 一、封装性
    • 1. 封装性的意义
      • 1.1 表现事物
      • 1.2 权限控制
      • 1.3 成员属性设置为私有
    • 2. 封装性的衍生知识
      • 2.1 struct和class区别
      • 2.2 友元
        • 2.2.1 全局函数做友元
        • 2.2.2 类做友元
        • 2.2.3 成员函数做友元
  • 二、继承性
    • 1. 继承的语法
    • 2. 继承方式
    • 3. 继承中的对象模型
      • 3.1 说明
      • 3.2 验证
    • 4. 继承同名成员处理方式
      • 4.1 同名属性
      • 4.2 同名函数
        • 4.2.1 参数相同
        • 4.2.2 参数不同
    • 4. 继承同名静态成员处理方式
    • 5. 继承中构造和析构顺序
      • 5.1 顺序说明
      • 5.2 个人理解
    • 6. 多继承语法
    • 7. 菱形继承
      • 7.1 菱形继承的概念
      • 7.2 菱形继承的问题与解决
        • 7.2.1 二义性
        • 7.2.2 资源浪费
      • 7.3 虚继承解决菱形继承问题的原理
    • 8. Java和C++在继承性方面易混淆的区别
  • 三、多态性
    • 1. 多态的介绍
    • 2. 多态的实现
      • 2.1 失败的多态
      • 2.2 成功的多态
      • 2.3 个人理解
    • 3. 纯虚函数和抽象类
      • 3.1 纯虚函数语法
      • 3.2 抽象类
    • 4. 虚析构和纯虚析构
      • 4.1 虚析构和纯虚析构语法
      • 4.2 虚析构和纯虚析构异同
      • 4.3 代码示例
      • 4.4 个人理解
        • 4.4.1 父类未使用虚析构函数
        • 4.4.2 父类使用虚析构函数

C++认为万事万物都皆为对象,对象上有其属性和行为。例如:人可以作为对象,属性有姓名、年龄、身高、体重…,行为有走、跑、跳、吃饭、唱歌…;车也可以作为对象,属性有轮胎、方向盘、车灯…,行为有载人、放音乐、放空调…。

具有相同性质的对象,我们可以抽象称为类,人属于人类,车属于车类。

C++面向对象的三大特性为:封装、继承、多态。

一、封装性

1. 封装性的意义

封装是C++面向对象三大特性之一。封装性的存在主要有两大意义:①将属性和行为作为一个整体,表现生活中的事物;②将属性和行为加以权限控制。

1.1 表现事物

C++中封装性的声明语法如下:

class 类名{ 
访问权限:属性  / 行为  
}

举例:设计圆类,求圆的周长

//圆周率
const double PI = 3.14;//1、封装的意义
//将属性和行为作为一个整体,用来表现生活中的事物//封装一个圆类,求圆的周长
//class代表设计一个类,后面跟着的是类名
class Circle
{
public:  //访问权限  公共的权限//属性int m_r;//半径//行为//获取到圆的周长double calculateZC(){//2 * pi  * r//获取圆的周长return  2 * PI * m_r;}
};int main() {//通过圆类,创建圆的对象// c1就是一个具体的圆Circle c1;c1.m_r = 10; //给圆对象的半径 进行赋值操作//2 * pi * 10 = = 62.8cout << "圆的周长为: " << c1.calculateZC() << endl;system("pause");return 0;
}

1.2 权限控制

类在设计时,可以把属性和行为放在不同的权限下,加以控制。访问权限有三种:public(公共权限 )、protected(保护权限)、private(私有权限)。三种权限的控制规则如下:

  1. 公共权限public: 类内可以访问 类外可以访问
  2. 保护权限protected:类内可以访问,类外除子类不可以访问
  3. 私有权限private: 类内可以访问,类外不可以访问

举例:

//三种权限
//公共权限  public     类内可以访问  类外可以访问
//保护权限  protected  类内可以访问  类外不可以访问
//私有权限  private    类内可以访问  类外不可以访问class Person
{//姓名  公共权限
public:string m_Name;//汽车  保护权限
protected:string m_Car;//银行卡密码  私有权限
private:int m_Password;public:void func(){m_Name = "张三";m_Car = "拖拉机";m_Password = 123456;}
};int main() {Person p;p.m_Name = "李四";//p.m_Car = "奔驰";  //保护权限类外访问不到//p.m_Password = 123; //私有权限类外访问不到system("pause");return 0;
}

1.3 成员属性设置为私有

我们设计类时,可以将所有成员属性设置为私有,可以自己控制读写权限。对于写权限,我们可以检测数据的有效性。

class Person {
public://姓名设置可读可写void setName(string name) {m_Name = name;}string getName(){return m_Name;}//获取年龄 int getAge() {return m_Age;}//设置年龄void setAge(int age) {if (age < 0 || age > 150) {cout << "你个老妖精!" << endl;return;}m_Age = age;}//情人设置为只写void setLover(string lover) {m_Lover = lover;}private:string m_Name; //可读可写  姓名int m_Age; //只读  年龄string m_Lover; //只写  情人
};int main() {Person p;//姓名设置p.setName("张三");cout << "姓名: " << p.getName() << endl;//年龄设置p.setAge(50);cout << "年龄: " << p.getAge() << endl;//情人设置p.setLover("苍井");//cout << "情人: " << p.m_Lover << endl;  //只写属性,不可以读取system("pause");return 0;
}

2. 封装性的衍生知识

2.1 struct和class区别

在C++中,struct和class唯一的区别就在于默认的访问权限不同:struct默认权限为公共,class默认权限为私有。

2.2 友元

生活中你的家有客厅(Public),有你的卧室(Private)。客厅所有来的客人都可以进去,但是你的卧室是私有的,也就是说只有你能进去。但是呢,你也可以允许你的好闺蜜好基友进去。

在程序里,有些私有属性也想让类外特殊的一些函数或者类进行访问,就需要用到友元的技术。换句话说,友元的目的就是让一个函数或者类 访问另一个类中私有成员。友元的关键字为friend

友元的一共有三种实现:① 全局函数做友元 ②类做友元 ③成员函数做友元。

2.2.1 全局函数做友元
class Building
{//告诉编译器 goodGay全局函数 是 Building类的好朋友,可以访问类中的私有内容friend void goodGay(Building * building);public:Building(){this->m_SittingRoom = "客厅";this->m_BedRoom = "卧室";}public:string m_SittingRoom; //客厅private:string m_BedRoom; //卧室
};void goodGay(Building * building)
{cout << "好基友正在访问: " << building->m_SittingRoom << endl;cout << "好基友正在访问: " << building->m_BedRoom << endl;
}void test01()
{Building b;goodGay(&b);
}int main(){test01();system("pause");return 0;
}
2.2.2 类做友元
class Building;
class goodGay
{
public:goodGay();void visit();private:Building *building;
};class Building
{//告诉编译器 goodGay类是Building类的好朋友,可以访问到Building类中私有内容friend class goodGay;public:Building();public:string m_SittingRoom; //客厅
private:string m_BedRoom;//卧室
};Building::Building()
{this->m_SittingRoom = "客厅";this->m_BedRoom = "卧室";
}goodGay::goodGay()
{building = new Building;
}void goodGay::visit()
{cout << "好基友正在访问" << building->m_SittingRoom << endl;cout << "好基友正在访问" << building->m_BedRoom << endl;
}void test01()
{goodGay gg;gg.visit();}int main(){test01();system("pause");return 0;
}
2.2.3 成员函数做友元

class Building;
class goodGay
{
public:goodGay();void visit(); //只让visit函数作为Building的好朋友,可以发访问Building中私有内容void visit2(); private:Building *building;
};class Building
{//告诉编译器  goodGay类中的visit成员函数 是Building好朋友,可以访问私有内容friend void goodGay::visit();public:Building();public:string m_SittingRoom; //客厅
private:string m_BedRoom;//卧室
};Building::Building()
{this->m_SittingRoom = "客厅";this->m_BedRoom = "卧室";
}goodGay::goodGay()
{building = new Building;
}void goodGay::visit()
{cout << "好基友正在访问" << building->m_SittingRoom << endl;cout << "好基友正在访问" << building->m_BedRoom << endl;
}void goodGay::visit2()
{cout << "好基友正在访问" << building->m_SittingRoom << endl;//cout << "好基友正在访问" << building->m_BedRoom << endl;
}void test01()
{goodGay  gg;gg.visit();}int main(){test01();system("pause");return 0;
}

二、继承性

继承是面向对象三大特性之一。有些类与类之间存在特殊的关系,例如下图:
在这里插入图片描述
我们发现,定义这些类时,下级别的成员除了拥有上一级的共性,还有自己的特性。这个时候我们就可以考虑利用继承的技术,减少重复代码。

1. 继承的语法

class A : public B; 

上述代码中,A类称为子类或派生类;B类称为父类或基类。

派生类中的成员,包含两大部分: 一类是从基类继承过来的,一类是自己增加的成员。

从基类继承过过来的表现其共性,而新增的成员体现了其个性。

2. 继承方式

继承方式一共有三种,分别是公共继承、保护继承、私有继承。三种方式的区别如下图所示:在这里插入图片描述
注意,这里的不可访问只是因为权限设置无法直接调用私有成员(包括属性和方法)进行访问,但是实际上子类也继承了父类的私有成员,可以通过其他方式进行访问。这点后面会陆续说到。

class Base1
{
public: int m_A;
protected:int m_B;
private:int m_C;
};//公共继承
class Son1 :public Base1
{
public:void func(){m_A; //可访问 public权限m_B; //可访问 protected权限//m_C; //不可访问}
};void myClass()
{Son1 s1;s1.m_A; //其他类只能访问到公共权限
}//保护继承
class Base2
{
public:int m_A;
protected:int m_B;
private:int m_C;
};
class Son2:protected Base2
{
public:void func(){m_A; //可访问 protected权限m_B; //可访问 protected权限//m_C; //不可访问}
};
void myClass2()
{Son2 s;//s.m_A; //不可访问
}//私有继承
class Base3
{
public:int m_A;
protected:int m_B;
private:int m_C;
};
class Son3:private Base3
{
public:void func(){m_A; //可访问 private权限m_B; //可访问 private权限//m_C; //不可访问}
};
class GrandSon3 :public Son3
{
public:void func(){//Son3是私有继承,所以继承Son3的属性在GrandSon3中都无法访问到//m_A;//m_B;//m_C;}
};

3. 继承中的对象模型

3.1 说明

子类中私有成员只是被隐藏了,无法直接访问到,但是还是会继承下去。

3.2 验证

class Base
{
public:int m_A;
protected:int m_B;
private:int m_C; //私有成员只是被隐藏了,但是还是会继承下去
};//公共继承
class Son :public Base
{
public:int m_D;
};void test01()
{cout << "sizeof Son = " << sizeof(Son) << endl;
}int main() {test01();system("pause");return 0;
}

在这里插入图片描述

利用【开发人员命令提示符工具】查看:打开工具窗口后,定位到当前C++文件的盘符,输入:

cl /d1 reportSingleClassLayout查看的类名   所属文件名

即可查看所需要查看类的内部数据,效果图如下:
在这里插入图片描述

4. 继承同名成员处理方式

4.1 同名属性

当子类定义了与父类同名的属性以后,子类会将父类的同名属性进行隐藏。此时直接访问同名属性时,调用的是子类定义的同名属性。

在子类内部,可以通过属性名子类::属性名的方式对只属于子类的同名属性进行调用;可以通过父类::属性名的方式对从父类继承下来的属于子类的同名属性进行调用。

在子类外部,可以可以通过子类对象.属性名子类对象.子类::属性名的方式对只属于子类的同名属性进行调用;可以通过子类对象.父类::属性名的方式对从父类继承下来的属于子类的同名属性进行调用。

class Base
{
public:int m_A = 10;
};//公共继承
class Son :public Base
{
public:int m_A = 100;public:void print_info() {//子类内cout << Base::m_A << endl;cout << Son::m_A << endl;cout << m_A << endl;}
};void test01()
{Son s;s.print_info();//子类外cout << s.Base::m_A << endl;cout << s.Son::m_A << endl;cout << s.m_A << endl;
}int main() {test01();system("pause");return 0;
}

4.2 同名函数

当子类定义了与父类同名的函数以后,子类会将父类的同名函数性进行隐藏。细分来说,可以再分为两种情况进行讨论:① 父类中,与子类的同名函数参数和子类相同;②父类中,与子类同名的函数参数和子类不同。

4.2.1 参数相同

在子类内部,可以通过函数名子类::函数名的方式对只属于子类的同名函数进行调用;可以通过父类::函数性名的方式对从父类继承下来的属于子类的同名函数进行调用。

在子类外部,可以通过子类对象.函数名子类对象.子类::函数名的方式对只属于子类的同名函数进行调用;可以通过子类对象.父类::属性名的方式对从父类继承下来的属于子类的同名函数进行调用。

class Base
{
public:void print_str() {cout << "str1" << endl;}
};//公共继承
class Son :public Base
{
public:void print_str() {cout << "str2" << endl;}void print_info() {//子类内Base::print_str();Son::print_str();print_str();}
};void test01()
{Son s;s.print_info();cout << "-----------------------"<< endl;//子类外s.Base::print_str();s.Son::print_str();s.print_str();
}int main() {test01();system("pause");return 0;
}
4.2.2 参数不同

在子类内部,由于子类的同名函数把父类所有名称相同的函数,都进行了隐藏,因此,无法通过函数名(参数)的方式对子类的继承的不同参数的同名函数进行调用;可以通过父类::函数名(参数)的方式对从父类继承下来的属于子类的同名函数进行调用。

在子类外部,也同样无法通过子类对象.函数名(参数)的方式对子类的继承的不同参数的同名函数进行调用,只能通过子类对象.父类::函数名(参数)的方式进行调用。

class Base
{
public:void print_str() {cout << "str1" << endl;}void print_str(string& str) {cout << str << endl;}
};//公共继承
class Base
{
public:void print_str() {cout << "str1" << endl;}void print_str(string& str) {cout << str << endl;}
};//公共继承
class Son :public Base
{	
public:void print_str() {cout << "str2" << endl;}void print_info() {string name = "jerry";//子类内//失败//print_str(name);Base::print_str(name);}
};void test01()
{Son s;s.print_info();cout << "-----------------------" << endl;//子类外string str = "hello";//失败//s.print_str(str);s.Base::print_str(str);}int main() {test01();system("pause");return 0;
}

4. 继承同名静态成员处理方式

静态成员和非静态成员出现同名,处理方式一致,只不过有两种访问的方式:通过对象和通过类名。

class Base {
public:static void func(){cout << "Base - static void func()" << endl;}static void func(int a){cout << "Base - static void func(int a)" << endl;}static int m_A;
};int Base::m_A = 100;class Son : public Base {
public:static void func(){cout << "Son - static void func()" << endl;}static int m_A;static void call_static() {cout << "Son  下 m_A = " << m_A << endl;cout << "Son  下 m_A = " << Son::m_A << endl;cout << "Base 下 m_A = " << Base::m_A << endl;Son::func();Son::Son::func();Son::Base::func();Son::Base::func(100);}
};int Son::m_A = 200;//同名成员属性
void test01()
{//通过对象访问cout << "通过对象访问: " << endl;Son s;cout << "Son  下 m_A = " << s.m_A << endl;cout << "Son  下 m_A = " << s.Son::m_A << endl;cout << "Base 下 m_A = " << s.Base::m_A << endl;//通过类名访问cout << "通过类名访问: " << endl;cout << "Son  下 m_A = " << Son::m_A << endl;cout << "Son  下 m_A = " << Son::Son::m_A << endl;cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}//同名成员函数
void test02()
{//通过对象访问cout << "通过对象访问: " << endl;Son s;s.func();s.Son::func();s.Base::func();cout << "通过类名访问: " << endl;Son::func(); Son::Son::func();Son::Base::func();//出现同名,子类会隐藏掉父类中所有同名成员函数,需要加作作用域访问Son::Base::func(100);
}//子类中访问
void test3() 
{Son::call_static();
}int main() {test01();test02();test3();system("pause");return 0;
}

5. 继承中构造和析构顺序

5.1 顺序说明

子类继承父类后,当创建子类对象,也会调用父类的构造函数。构造函数的调用顺序为:先调用父类构造函数,再调用子类构造函数。析构函数的调用顺序为:先调用子类析构函数,再调用父类析构函数。

class Base 
{
public:Base(){cout << "Base构造函数!" << endl;}~Base(){cout << "Base析构函数!" << endl;}
};class Son : public Base
{
public:Son(){cout << "Son构造函数!" << endl;}~Son(){cout << "Son析构函数!" << endl;}};void test01()
{//继承中 先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反Son s;
}int main() {test01();system("pause");return 0;
}

5.2 个人理解

c++创建一个子类对象时会调用父类的构造函数,但不会创建另外一个父类对象,只是初始化子类中属于父类的成员。

创建一个对象的时候,发生了两件事情,一是分配对象所需的内存,二是调用构造函数进行初始化。子类对象包含从父类对象继承过来的成员,实现上来说,一般也是子类的内存区域中有一部分就是父类的内存区域。调用父类构造函数的时候,这块父类对象的内存区域就被初始化了。为了避免未初始化的问题,语法强制子类调用父类构造函数。

6. 多继承语法

C++允许一个类继承多个类,语法如下:

class 子类 :继承方式 父类1 , 继承方式 父类2...

但是,多继承可能会引发父类中有同名成员出现,此时子类在使用时,需要加作用域区分。C++实际开发中不建议用多继承。

class Base1 {
public:Base1(){m_A = 100;}
public:int m_A;
};class Base2 {
public:Base2(){m_A = 200;  //开始是m_B 不会出问题,但是改为mA就会出现不明确}
public:int m_A;
};//语法:class 子类:继承方式 父类1 ,继承方式 父类2 
class Son : public Base2, public Base1 
{
public:Son(){m_C = 300;m_D = 400;}
public:int m_C;int m_D;
};//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{Son s;cout << "sizeof Son = " << sizeof(s) << endl;cout << s.Base1::m_A << endl;cout << s.Base2::m_A << endl;
}int main() {test01();system("pause");return 0;
}

7. 菱形继承

7.1 菱形继承的概念

在这里插入图片描述
菱形继承:两个派生类继承同一个基类,某个类同时继承者两个派生类,这种继承被称为菱形继承,或者钻石继承。

7.2 菱形继承的问题与解决

7.2.1 二义性
  1. 问题:羊继承了动物的数据,驼同样继承了动物的数据,当草泥马使用数据时,就会产生二义性。
  2. 解决方式:通过使用作用域对数据进行区分。
class Animal
{
public:int m_Age;
};class Sheep : public Animal {};
class Tuo : public Animal {};
class SheepTuo : public Sheep, public Tuo {};void test01()
{SheepTuo st;st.Sheep::m_Age = 100;st.Tuo::m_Age = 200;cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
}int main() {test01();system("pause");return 0;
}
7.2.2 资源浪费
  1. 问题:草泥马继承自动物的数据继承了两份,其实我们应该清楚,这份数据我们只需要一份就可以。
  2. 解决方式:通过使用虚继承的方式可以解决此问题。让羊和驼都以虚继承的方式来继承动物类,羊驼以正常的继承方式继承羊类和驼类。此时,动物类成为虚基类。虚继承同样可以解决二义性的问题。
class Animal
{
public:int m_Age;
};//继承前加virtual关键字后,变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo   : virtual public Animal {};
class SheepTuo : public Sheep, public Tuo {};void test01()
{SheepTuo st;st.Sheep::m_Age = 100;st.Tuo::m_Age = 200;cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;cout << "st.m_Age = " << st.m_Age << endl;
}int main() {test01();system("pause");return 0;
}

7.3 虚继承解决菱形继承问题的原理

采用正常的继承方式,羊驼类内的结构如图,可以看到羊驼类中有两份m_Age数据,一份来源于羊类,一份来源于驼类。
在这里插入图片描述
采用虚继承的方式,羊驼类内的结构如图,可以发现,此时羊驼类内部只有一个m_Age数据,从羊类和驼类中继承的都是vbptr。vbptr是Vitrual Base Pointer,即虚基类指针的意思,这个指针会指向羊驼类中各自的vbtable。vbtable是Virtual Base Table,即虚基类表格的意思,该表格记录了偏移量。vbptr所在的位置+vbtable中的偏移量=实际存放值的位置,下图中羊类的vbptr位置为4,羊类的vbtable记录的偏移量为8,0+8=8,8就是m_Age的位置。
在这里插入图片描述
可以看出,此时羊驼类中只有一个m_Age。无论通过何种方式访问m_Age,都是在访问同一个数据。由此,也就解决了菱形继承带来的二义性和资源浪费的问题。

8. Java和C++在继承性方面易混淆的区别

JavaC++
Java中只有一种继承方式C++中有三种继承方式
Java中子类会重写父类中同名同参数的方法,而与父类中同名不同参数的方法是重载的关系C++中会隐藏父类中所有同名方法(不管参数相同不相同)

三、多态性

多态是C++面向对象三大特性之一。

1. 多态的介绍

C++中的多态分为两类:

  1. 静态多态: 函数重载和运算符重载属于静态多态,复用函数名。
  2. 动态多态: 派生类和虚函数实现运行时多态。

静态多态和动态多态区别:

  1. 静态多态的函数地址早绑定:编译阶段确定函数地址。
  2. 动态多态的函数地址晚绑定:运行阶段确定函数地址。

动态多态的本质是父类指针或引用指向子类对象。本部分所介绍的多态,指的都是动态多态。因此,为了方便起见,下文只要说到多态的地方,都代表动态多态。

2. 多态的实现

如果想要实现多态,必须要满足以下两个条件:

  1. 两个类有继承关系
  2. 子类重写父类中的虚函数

重写和重载是两种概念:

  1. 重写:函数返回值类型、函数名、参数列表完全一致称为重写
  2. 重载:函数的参数名相同,而参数列表不同

2.1 失败的多态

class Animal
{
public:void speak(){cout << "动物在说话" << endl;}
};class Cat :public Animal
{
public:void speak(){cout << "小猫在说话" << endl;}
};class Dog :public Animal
{
public:void speak(){cout << "小狗在说话" << endl;}};void DoSpeak(Animal& animal)
{animal.speak();
}void test01()
{Cat cat;DoSpeak(cat);Dog dog;DoSpeak(dog);
}int main() {test01();system("pause");return 0;
}

此时,屏幕输出的都是【动物在说话】,并没有真正的实现多态。这是因为DoSpeak属于地址早绑定,该函数在编译时已经确定了函数的地址。

2.2 成功的多态

class Animal
{
public:virtual void speak(){cout << "动物在说话" << endl;}
};class Cat :public Animal
{
public:void speak()//也可以加上virtual关键字,不加也没事{cout << "小猫在说话" << endl;}
};class Dog :public Animal
{
public:void speak()//也可以加上virtual关键字,不加也没事{cout << "小狗在说话" << endl;}};void DoSpeak(Animal& animal)
{animal.speak();
}void test01()
{Cat cat;DoSpeak(cat);Dog dog;DoSpeak(dog);
}int main() {test01();system("pause");return 0;
}

此时,屏幕输出的是【小猫在说话】和【小狗在说话】,实现了真正的实现多态。那么为什么函数定义为虚函数就可以实现多态性呢?
在这里插入图片描述

  1. 当函数只是普通的函数时,类中并不存储该函数。
  2. 当函数是虚函数时,类中会存储一个vfptr(Virtual Function Pointer),即虚函数(表)指针,该指针会指向vftable(Virtual Function Table)虚函数表,表中会记录虚函数的地址&类名::函数(在上述例子中就是&Animal::speak)。
  3. 子类继承该类但并未重写虚方法时,子类也会有一个和父类完全相同的vfptr和vftable。
  4. 子类继承该类并重写虚方法以后,子类会将虚函数表内部存放的地址进行替换,替换成子类的虚函数地址(在上述例子中就是&Cat::speak)。
  5. 当父类的指针或引用指向子类对象的时候,就会去子类对象的虚函数表中找对应的函数,也就发生了多态。

2.3 个人理解

  1. 发生多态,最核心的原因就是地址的晚绑定,即在运行阶段才能真正的确定函数的地址。
  2. 在未采用虚函数时,类中不会存放函数的地址,函数的地址是类外的某个具体内存。此时函数地址的确认不依赖于具体的对象,因此直接能够在编译阶段完成函数地址的确认,所以无法发生多态。
  3. 采用虚函数以后,类中会存放函数的地址指针,地址指针指向虚函数表,虚函数表指向真正运行的函数地址。此时,函数地址的确认要依赖于具体的对象,所以无法在编译阶段完成函数地址的确认,必须要在运行时,根据具体指向的对象找到函数的地址,进行调用,因此才能实现多态。

3. 纯虚函数和抽象类

在多态中,通常父类中虚函数的实现是毫无意义的,主要都是调用子类重写的内容,因此可以将虚函数改为纯虚函数。

3.1 纯虚函数语法

virtual 返回值类型 函数名 (参数列表)= 0 ;

3.2 抽象类

当类中有了纯虚函数,这个类也称为抽象类。抽象类具有以下特点:

  1. 无法实例化对象。
  2. 子类必须重写抽象类中的纯虚函数,否则也属于抽象类。
class Base
{
public://纯虚函数//类中只要有一个纯虚函数就称为抽象类//抽象类无法实例化对象//子类必须重写父类中的纯虚函数,否则也属于抽象类virtual void func() = 0;
};class Son :public Base
{
public:virtual void func() {cout << "func调用" << endl;};
};void test01()
{Base * base = NULL;//base = new Base; // 错误,抽象类无法实例化对象base = new Son;base->func();delete base;//记得销毁
}int main() {test01();system("pause");return 0;
}

4. 虚析构和纯虚析构

多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放时无法调用到子类的析构代码,此时,就需要将父类中的析构函数改为虚析构或者纯虚析构。

4.1 虚析构和纯虚析构语法

虚析构语法:

virtual ~类名(){}

纯虚析构语法:

virtual ~类名() = 0;
类名::~类名(){}//纯虚析构需要实现

4.2 虚析构和纯虚析构异同

虚析构和纯虚析构共性:

  1. 可以解决父类指针释放子类对象。
  2. 都需要有具体的函数实现。

虚析构和纯虚析构区别:

  1. 如果是纯虚析构,该类属于抽象类,无法实例化对象。

4.3 代码示例

class Animal {
public:Animal(){cout << "Animal 构造函数调用!" << endl;}virtual void Speak() = 0;//析构函数加上virtual关键字,变成虚析构函数//virtual ~Animal()//{//	cout << "Animal虚析构函数调用!" << endl;//}virtual ~Animal() = 0;
};Animal::~Animal()
{cout << "Animal 纯虚析构函数调用!" << endl;
}//和包含普通纯虚函数的类一样,包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。class Cat : public Animal {
public:Cat(string name){cout << "Cat构造函数调用!" << endl;m_Name = new string(name);}virtual void Speak(){cout << *m_Name <<  "小猫在说话!" << endl;}~Cat(){cout << "Cat析构函数调用!" << endl;if (this->m_Name != NULL) {delete m_Name;m_Name = NULL;}}public:string *m_Name;
};void test01()
{Animal *animal = new Cat("Tom");animal->Speak();//通过父类指针去释放,会导致子类对象可能清理不干净,造成内存泄漏//怎么解决?给基类增加一个虚析构函数//虚析构函数就是用来解决通过父类指针释放子类对象delete animal;
}int main() {test01();system("pause");return 0;
}

4.4 个人理解

4.4.1 父类未使用虚析构函数

如果在父类没有使用虚析构函数的时候对父类指针进行了释放,那么会调用父类的析构函数(早绑定),此时子类的空间会被释放(地址指向的就是子类的地址),但不会调用子类的析构函数。在释放子类的空间时,指针自身并不关心它所指向的对象有哪些成员变量,因此子类的成员变量也会被一并释放。然而,如果这个子类有任何动态分配的内存(例如使用 new 创建的数组或者其他对象),那么这些动态分配的内存会在子类对象被释放时不会被自动回收,最终会造成内存泄漏。

4.4.2 父类使用虚析构函数

如果在父类使用虚析构函数的时候对父类指针进行了释放,那么会调用子类的析构函数(晚绑定),此时子类的空间会被释放,如果这个子类有任何动态分配的内存,我们可以在子类空间中人为进行释放来避免内存泄露。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/web/37.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

鸿蒙Next和鸿蒙4.0开发者如何选择

目录 一、 开头一句话重点落在鸿蒙原生开发&#xff0c;也就是ArkUI、Ability、ArkTS、ArkWeb、ArkData等。不管将来是鸿蒙Next2.0或者鸿蒙6.0都游刃有余。 二、 鸿蒙4.0与鸿蒙Next的共性共性概述详细分析总结 三、HarmonyOS Next与HarmonyOS 4的主要区别内核与兼容性设备与应用…

智能电视/盒子长文字输入困难?手把手教您解决这个难题!(电视盒子跨屏输入/打字,亲测有效!)

文章目录 📖 介绍 📖🏡 演示环境 🏡📒 解决方案 📒📝 方法一📝 方法二🎈 获取方式 🎈⚓️ 相关链接 ⚓️📖 介绍 📖 在使用智能电视/电视盒子的时候,会遇到这样一个场景:需要输入一个很长的网址,或者是想要粘贴一段很长的文字。如何使用遥控器要完成…

sqli-labs-master(Less1--Less5)

Sql-labs-master通关攻略_sqli-labs-master 全部通关-CSDN博客 sqli-labs-master靶场搭建&#xff0c;1-10关详解-CSDN博客 小白勇闯sqli-labs-master1-22关_sqlilabs第22关-CSDN博客 搭建靶场 靶场&#xff1a; GitHub - Audi-1/sqli-labs: SQLI labs to test error base…

浅谈成为程序员后我明白的道理

当我成为程序员后&#xff0c;我明白了以下几点&#xff1a; 编程是一门持续学习的技能&#xff1a;作为程序员&#xff0c;我意识到编程是一个不断发展和变化的领域。新的编程语言、框架和技术不断出现&#xff0c;需要不断学习和适应。我意识到要持续学习新的知识和技能&…

机器学习—特征预处理和降维(四)

什么是特征预处理&#xff1f; 通过一些转换函数将特征数据转换成更加适合算法模型的特征数据过程 1包含内容 数值型数据的无量纲化&#xff1a; 归一化标准化 2特征预处理API sklearn. preprocessing为什么要进行归一化 or 标准化&#xff1f; 特征的单位或者大小相差较大…

学习了解大模型的四大缺陷

由中国人工智能学会主办的第十三届吴文俊人工智能科学技术奖颁奖典礼暨2023中国人工智能产业年会于2024年4月14日闭幕。 会上&#xff0c;中国工程院院士、同济大学校长郑庆华认为&#xff0c;大模型已经成为当前人工智能的巅峰&#xff0c;大模型之所以强&#xff0c;是依托了…

请警惕,这10本期刊已被SCI剔除,部分涉嫌灌水

科睿唯安于4月15日更新了SCIE、SSCI、AHCI、ESCI四大数据库最新收录期刊目录。 2024年第一版——2024年1月24日更新 2024年第二版——2024年2月19日更新 2024年第三版——2024年3月18日更新 2024年第四版——2024年4月15日更新 本次目录中共收录期刊23368本。 【SCIE数据…

苹果开发初学者指南:Xcode 如何为运行的 App 添加环境变量(Environmental Variable)

概览 Xcode 15 在运行 SwiftUI 代码时突然报告如下警告&#xff1a; Error: this application, or a library it uses, has passed an invalid numeric value (NaN, or not-a-number) to CoreGraphics API and this value is being ignored. Please fix this problem. 不仅如此…

react之useState详解

1. 为什么要用useState&#xff1f; 它是React 16.8 的新特性&#xff0c;我们在React里面一般都是用Class去写组件&#xff0c;但是有时候会发现不用它更方便&#xff0c;但是问题来了&#xff1a;不用Class的时候&#xff0c;数据的状态改变如何存储呢&#xff1f;如果你用 …

数据结构-堆详解

堆 图片&#xff1a; 二叉堆的父节点为这个子树的最值。 如何维护它。 我们发现它是一棵二叉树&#xff0c;那就自然满足若父节点为 x x x 则左儿子节点为 x 2 x\times2 x2 右儿子为 x 2 1 x\times 2 1 x21 这是显然的&#xff0c;但如果写成指针或结构体就太麻烦了&…

Redis的特性与安装

回顾 Redis是一个在内存中存储数据的中间件&#xff0c;可以用来当数据库用&#xff0c;也可以作为缓存用(这里的缓存往往是对数据库缓存)。 中间件&#xff1a;和业务无关的服务&#xff0c;功能更加通用&#xff0c;如&#xff1a;数据库&#xff0c;缓存&#xff0c;消息队…

【笔试强训】Day1 --- 数字统计 + 两个数组的交集 + 点击消除

文章目录 1. 数字统计2. 两个数组的交集3. 点击消除 1. 数字统计 【链接】&#xff1a;数字统计 解题思路&#xff1a;模拟&#xff0c;利用数学知识&#xff0c;计算每个数字中2出现的个数。&#xff08;这里也可以将数字转换成字符串来统计字符’2’出现的个数&#xff09…

如何使用Flask搭建web程序框架并实现无公网IP远程访问本地程序

文章目录 前言1. 安装部署Flask并制作SayHello问答界面2. 安装Cpolar内网穿透3. 配置Flask的问答界面公网访问地址4. 公网远程访问Flask的问答界面 前言 Flask是一个Python编写的Web微框架&#xff0c;让我们可以使用Python语言快速实现一个网站或Web服务&#xff0c;本期教程…

bonding原理分析和问题排查

bonding原理 发送端&#xff1a; 使用网卡bond3模式&#xff08;广播模式BOND_MODE_BROADCAST&#xff09;将报文从两个网卡同时发出&#xff0c;无需修改报文。 接收端&#xff1a; 根据发送节点时间的链路通断状态&#xff0c;接收端设置一条线路为活动线&#xff0c;另一条…

免费泛域名SSL如何申请,和通配符有什么区别

-----让我们明确什么是泛域名。所谓泛域名&#xff0c;是指使用星号&#xff08;*&#xff09;作为子域名的占位符&#xff0c;它可以匹配任意子域名。-----而通配符在域名中&#xff0c;它可以出现在主域名的任何位置&#xff0c;它可以用于主域名和子域名的保护。 主要应用场…

XZ-Utils后门事件过程及启示

Part.01 背景 XZ-Utils&#xff08;曾经叫做LZMA Utils&#xff09;是一款开源的无损压缩命令行工具&#xff0c;是用C语言编写的跨平台工具&#xff0c;可以用于类Unix系统和Windows系统。在多数情况下&#xff0c;xz的压缩率要好过gzip和bzip2&#xff0c;解压速度也快过bz…

Java的数组定义和使用

目录 1.前言 2.数组的概念 3.在Java中的创建和初始化 3.1数组的创建 3.2数组的初始化 4.关于使用 4.1数组元素的访问 4.2数组的遍历 4.3length和length()的区别 5.数组其实是引用类型数据 5.1初始JVM的内存分布 5.2基本类型变量与引用类型变量的区别 5.3关于null的认识 5.4设计…

工作流JBPM画图与配置

文章目录 ☃️7.1 画图☃️7.2 配置7.2.1 配置任务办理人7.2.1.1 写死的方式配置任务办理人&#xff08;不推荐&#xff09;7.2.1.2 #{}方式配置任务办理人7.2.1.3 实现接口方式配置任务办理人7.2.1.4 方法指定方式分配任务办理人 7.2.2 配置节点属性7.2.2.1 判断节点(decision…

Sourcetree安装使用(补个笔记)

Sourcetree介绍 Sourcetree是一款免费的Git图形化客户端&#xff0c;它由Atlassian开发&#xff0c;提供了跨平台的支持&#xff0c;可运行在Windows和Mac操作系统上。Sourcetree可以让开发者更方便地使用Git来管理代码&#xff0c;不需要在命令行中输入复杂的Git命令&#xf…

HTML学习笔记:链接target属性

关于target的使用&#xff1a; <a href"https://www.baidu.com" target"_parent">网址链接</a>其中关于target四个特殊目标的理解&#xff0c;W3school上的解释为&#xff1a; HTML 标签的 target 属性 其中_black和_self两个属性很好理解&…