C++基础复习——Day2

2023-05-16

类和对象

- 封装
- 对象的初始化和清理
- - 构造函数和析构函数
  - 构造函数的分类及调用
  - 拷贝构造函数调用时机
  - 深拷贝与浅拷贝
- C++对象模型和this指针
- 友元
- 运算符重载
- - 加号运算符重载
  - 左移运算符重载
  - 递增运算符重载
  - 赋值运算符重载
- 继承
- - 继承的基本用法
  - 继承方式
  - 继承中的对象模型
  - 继承中构造和析构顺序
  - 继承同名成员处理方式
  - 继承同名静态成员处理方式
  - 多继承语法
- 多态
- - 多态的基本概念
  - 多态深入剖析
  - 纯虚函数和抽象类
  - 虚析构和纯虚析构

C++面向对象三大特性： 封装、继承、多态
C++认为 万物皆为对象，对象上有其属性和行为

封装

封装的意义一

将属性和行为作为一个整体，表现生活事物
将属性和行为加以权限

语法：class 类名 { 访问权限：属性 / 行为}

示例：设计一个圆类，求圆的周长

#include <iostream>
using namespce std;
//圆周率
const double PI = 3.14;
//class 代表一个类，类后面紧跟的就是类名称
class Circle
{
	//访问权限
public://公共权限
	//属性
	int m_r; //半径
	//行为
	double calculateZC()// 获取圆的周长
	{
		return 2 * PI * m_r;
	}
};

int main()
{
	//通过圆类创建具体的圆（对象）
	Circle cl; //实例化对象
	//给圆对象属性赋值
	cl.m_r = 10;
	cout << "圆的周长：" << cl.calculateZC() << endl;
}

封装的意义二
类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：

public 公共权限，成员类内可以访问类外可以访问
protected 保护权限，成员类内可以访问类外不可以访问儿子也可以访问父亲中的内容
private 私有权限，成员类内可以访问类外不可以访问

class Person
{
public: //
	string m_Name; 
protected:
	string m_Car;
private:
	int m_Password;

public: //类内都可以访问
	void func()
	{
		m_Name = "Ricardo";
		m_Car = "Benz";
		m_Password = 123456;
	}
};

int main()
{
	//实例化对象
	Person p1;
	p1.m_Name = "Jay";
	p1.m_Car = "Audi";  //错误，不能在类外访问
	p1.m_Password = 234567; //错误，不能在类外访问
	p1.func(); //错误，不能在类外访问
}

struct 和 class 的区别
在C++中struct 和 class的唯一区别时默认的访问权限不同
区别：

struct 默认权限为公共
class 默认权限为私有

成员属性设置为私有
优点：1.将所有成员属性设置为私有，可以自己控制读写权限
2.对于写权限，我们可以监测数据的有效性

class Person()
{
public:
	void setName(string name)
	{
		m_Name = name;
	}
	string getName() //返回字符串
	{
		return m_Name;
	}
	int getAge()
	{
		m_Age = 0;
		return m_Age;
	}
	void setLover(string lover) //只可以在内部访问，不提供外部访问接口
	{
		m_Lover = lover;
	}
private:
	string m_Name; //可读可写
	int m_Age;	//只读
	string m_Lover;
};
int main()
{
	Person p;
	p.setName("Ricardo");
	cout << "Name is："<< p.getName()<<endl;
	cout << "Age is: "<< p.getAge();<<endl;
	p.setLover("Hamham");//只能写 ，没有提供读的函数
	
}

对象的初始化和清理

C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置

构造函数和析构函数

C++利用了构造函数和析构函数解决了对象或变量没有初始状态，以及使用完后没有及时清理的问题，这两个函数会被编译器自动调用，完成对象初始化和清理工作。
因此如果我们不提供构造和析构，编译器会提供，编译器提供的构造函数和析构函数是空实现

构造函数：主要用于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用
析构函数：主要作用在对象销毁前系统自动调用，执行一些清理工作

构造函数语法：类名( ) { }

构造函数，没有返回值也不写void
函数名称与类名相同
构造函数可以有参数，因此可以发生重载
程序在调用对象时会自动调用构造，无需手动调用，而且只会调用一次

析构函数语法：~类名( ) { }

析构函数，没有返回值也不写void
函数名称与类名相同，在名称前加上符号~
析构函数不可以有参数，因此不可以发生重载
程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次

class Person
{
public: 
	//构造函数
	Person()
	{
		cout<<"Person 构造函数的调用"<<endl;
	}
	//析构函数 ，对象释放后才执行
	~Person()
	{
		cout<<"Person 析构函数的调用"<<endl;
	}
};

vodi test01()
{
	Person p; //创建在栈区的数据，test01执行完后会释放这个对象，自动执行析构函数
}
int main()
{
	test01();//编译器会自动调用构造函数，析构函数
	system("pause");
	return 0;
}

构造函数的分类及调用

两种分类方式：
按参数分：有参构造 和 无参构造
按类型分：普通构造 和 拷贝构造
三种调用方法：
括号法；显示法；隐式转换法；

class Person
{
public: 
	int age;
	//构造函数
	Person()
	{
		cout<<"Person 无参构造函数的调用"<<endl;
	}
	
	Person(int a)
	{
		age = a;
		cout<<"Person 有参构造函数的调用"<<endl;
	}
	
	//拷贝构造函数
	Person(const Person &p) //按照引用方式传进来
	{
		//将传入的人身上的所有属性，拷贝到我身上
		age = p.age
		cout<<"Person 拷贝构造函数的调用"<<endl;
	}
	
	//析构函数 ，对象释放后才执行
	~Person()
	{
		cout<<"Person 析构函数的调用"<<endl;
	}
};

vodi test01()
{
	//括号法
	Person p(); //调用默认构造函数时，不要加()，编译器会认为是函数声明,不会认为在创建对象
	Person p; //默认构造函数调用
	Person p2(10); //有参构造函数
	Person p3(p2); //拷贝构造函数
	cout << "p2的年龄为：" << p2.age <<endl;
	cout << "p3的年龄为：" << p3.age <<endl;
	//显示法
	Person p2 = Person(10); //调用有参构造
	Person p3 = Person(p2); // 拷贝构造
	Person(10);  //匿名对象  特点：当执行结束后，系统会立即回收掉匿名
	//不要利用拷贝构造函数 初始化匿名对象，编译器会认为 Person(p3) ==Person p3
	//隐式转换法
	Person p4 = 10; //相当于写了 Person p4 = Person(10);  有参构造
	Person p5 = p4; //拷贝构造
}

int main()
{
	test01();//编译器会自动调用构造函数，析构函数
	system("pause");
	return 0;
}

拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况：

使用一个已经创建完毕的对象来初始化一个对象
值传递的方式给函数参数传值
以值方式返回局部对象

class Person
{
public: 
	//构造函数
	Person()
	{
		cout<<"Person 默认构造函数的调用"<<endl;
	}
	Person(int age)
	{
		m_Age = age;
		cout<<"Person 有参构造函数的调用"<<endl;
	}
	
	Person(const Person &p) //按照引用方式传进来
	{
		//将传入的人身上的所有属性，拷贝到我身上
		m_Age = p.m_Age;
		cout<<"Person 拷贝构造函数的调用"<<endl;
	}
	
	//析构函数 ，对象释放后才执行
	~Person()
	{
		cout<<"Person 析构函数的调用"<<endl;
	}
	int m_Age;
};

void test01()
{
	Person p1(20);
	Person p2(p1);
	cout << "p2的年龄为：" << p2.m_Age << endl;
}
// 值传递的方式给函数参数传值
void doWork(Person p)
{
	
}
void test02();
{
	Person p;
	doWork(p);
}
//值方式返回局部对象
Person doWork2()
{
	Person p1;
	return p1;
}
void test03()
{
	Person p = doWork2();
}

深拷贝与浅拷贝

深拷贝是面试经典问题，也是常见的一个坑
浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作

class Person
{
public: 
	//构造函数
	Person()
	{
		cout<<"Person 默认构造函数的调用"<<endl;
	}
	Person(int age, int height)
	{
		m_Age = age;
		m_Height = new int(height); //new一个空间 , 使用m_Height指针接收这个空间
		cout<<"Person 有参构造函数的调用"<<endl;
	}
	~Person() 
	{
		//析构代码发挥作用：将堆区开辟数据做释放操作
		if(m_Height !==NULL)
		{
			delete	m_Height;
			m_Height = NULL;
		}
		cout<<"Person 析构函数的调用"<<endl;
	}
	int m_Age; //年龄
	int *m_Height; //身高 ，把身高的数据开辟到堆区
};
void test01()
{
	Person p1(18, 160);
	cout << "p1的年龄为：" << p1.m_Age <<"身高为："<< *p1.m_Height << endl;
	Person p2(p1); // 我们没有提供拷贝构造函数，但是编译器提供了浅拷贝的操作，把age传递输出
	cout << "p2的年龄为：" << p2.m_Age << "身高为："<< *p2.m_Height << endl;
}

在这里插入图片描述
如果使用浅拷贝，在调用析构函数时，先进行p2的析构，就将堆区的空间释放了一次，而后面进行p1析构，再次将堆区堆区的空间释放，重复释放空间，所以是非法操作。

所以浅拷贝的问题要利用深拷贝的方法进行解决，用两块空间存储相同的数据
在这里插入图片描述
改进上述代码，在类内自己实现拷贝构造函数

// 自己实现拷贝构造函数 解决浅拷贝带来的问题
Person(const Person &p)
{
	cout << "Person拷贝构造函数的调用" <<endl;
	m_Age = p.m_Age;
	//m_Height = p.m_Height; 编译器默认实现就是这行代码
	//深拷贝操作
	m_Height = new int(*p.m_Height);
}

C++对象模型和this指针

成员变量和成员函数分开存储

空对象占用内存空间为：1，每个空对象也应该有一个独一无二的内存地址
非静态成员变量属于类的对象上
静态成员变量，非静态和静态成员函数都不属于类对象上

class Person
{
	int m_A;
};

this 指针概念
多个同类型的对象会共用一块代码，这一块代码如何区分哪哥对象调用自己？
C++通过提供特殊的对象指针，this指针解决上述问题，this指针指向被调用的成员函数所属对象

this 指针是隐含每一个非静态成员函数内的一种指针
this指针不需要定义；直接使用即可
this指针的本质是指针常量，指针的指向是不可以修改的，指向的内容可以更改
this指针的用途：

1、解决名称冲突
2、返回对象本身使用 *this

class Person
{
public:
	Person(int age)
	{
		this->age = age;  //使用this指针解决同名的冲突，this指向的是p1
	}
	
	Person& PersonAddAge(Person &p) //使用引用方式传递、使用引用方式返回
	{
		this->age += p.age;  //将另一对象年龄加到自己身上
		return *this; //this 是指向 p2的指针，而 *this指向的就是p2这个对象本体
	}
	int age;
};
//1、解决名称冲突
void test01()
{
	Person p1(18);
}

//2、返回对象本身用 *this
void test02()
{
	Person p1(10);
	Person p2(10);
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1); //使用引用返回指针可以循环调用
	//链式编程思想
	cout << "p2的年龄为：" << p2.age << endl ;
}

空指针访问成员函数

class Person
{
public:
	void showClassName()
	{
		cout << "this is Person class" << endl ;
	}
	void showPersonAge();
	{
		//报错原因是因为传入的指针是为NULL
		cout << "age = " << this->m_Age << endl ;
		if(this == NULL)
		{
			return;
		}
	}
	int m_Age;
};
void test01()
{
	Person *p = NULL;
	p->showClassName();
}

const修饰成员函数
常函数：

成员函数加const后我们称这个函数为常函数
常函数内不可以修改成员属性
成员属性声明时加关键字mutable后，在常函数中仍然可以修改

常对象：

声明对象前加const称该对象为常对象
常对象只能调用常函数

class Person
{
public:
	//常函数
	void showPerson() const //在成员函数后面加const，修饰的是this指针，让指针指向的值也不可以修改
	{
		//this->m_A = 100 ;// 报错，不允许修改
		this->m_B = 100;//可以修改
	}
	void func()
	{
		m_A = 100; //在普通成员函数下可以修改m_A的值
	}
	int m_A;
	mutable int m_B;
};

void test02()
{
	const Person p; //在对象前加const，变为常对象
	p.m_A = 100; //报错，不可以修改
	p.m_B = 100; //可以修改
	p.func(); // 常对象只能调用常函数，不可以调用普通成员函数
}

友元

友元的目的就是让一个函数或者类访问另一个类中私有成员
友元的关键字：friend
友元的三种实现：

全局函数做友元
类做友元
成员函数做友元

全局函数做友元

class Building
{
	friend void goodGuy(Building *building); //goodGuy全局函数是Building的友元函数，可以访问其私有成员
public:
	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};
//全局函数
void goodGuy(Building *building)
{
	cout << "好基友全局函数正在访问：" << builing->m_StittingRoom << endl;
	cout << "好基友全局函数正在访问：" << builing->m_BedRoom << endl;
}

void test01()
{
	Building builing;
	goodGuy(&building);
}

类做友元

class Building;
class GoodGuy
{
public:
	GoodGuy(); //构造函数声明
	void visit();
	Building *building;
};

class Building
{
	friend class GoodGuy; //GoodGuy类是Building朋友，可以访问本类中私有成员
public:
	Building();
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};
//类外写成员函数
GoodGuy::GoodGuy()
{
	//创建建筑物对象
	building = new Building; //在堆区new一个地址接收Building对象，并让指针building接收这个对象
}

void GoodGuy::visit()
{
	cout << "好基友全局函数正在访问：" << builing->m_StittingRoom << endl;
	cout << "好基友全局函数正在访问：" << builing->m_BedRoom << endl;
}

Building::Building();
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}

void test01()
{
	GoodGuy gg;
	gg.visit();
}

成员函数做友元

class Building;
class GoodGuy
{
public:
	GoodGuy(); 
	void visit(); //让visit函数可以访问Building中私有成员
	void visit2(); //让visit函数不可以访问Building中私有成员
	Building *building;
};

class Building
{
	friend void GoodGuy::visit(); //GoodGuy类下的visit函数是Building朋友，可以访问本类中私有成员
public:
	Building();
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};
//类外实现成员函数
Building::Building();
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}
GoodGuy::GoodGuy()
{
	//创建建筑物对象
	building = new Building; //在堆区new一个地址接收Building对象，并让指针building接收这个对象
}

void GoodGuy::visit()
{
	cout << "好基友全局函数正在访问：" << builing->m_StittingRoom << endl;
	cout << "好基友全局函数正在访问：" << builing->m_BedRoom << endl;
}
void GoodGuy::visit2()
{
	cout << "好基友全局函数正在访问：" << builing->m_BedRoom << endl;//类外不可访问
}

运算符重载

概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

加号运算符重载

例如：定义两个类，实现相加

class Person
{
public:
	int m_A;
	int m_B;
};
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 10;
p2.m_B = 10;
Person p3 = p1 + p2; //编译器不理解

解决方法：
1、通过成员函数重载加号+

class Person
{
public:
	Person operator +(Person &p)//返回的是一个Person类,传入一个person类的引用，地址传递
	{
	Person temp;
	temp.m_A = this->m_A + p.m_A; //使用this指针解决 名字冲突
	temp.m_B = this->m_B + p.m_B;
	return temp;
	}
	int m_A;
	int m_B;
};
void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;
	//Person p3 = p1.operator+(p2);  成员函数重载本质调用
	Person p3 = p1 + p2;  //可以简化为这种形式

	cout << "p3.m_A = "<<p3.m_A<<endl;
	cout << "p3.m_B = "<<p3.m_B<<endl;
}

2、通过全局函数重载加号+

Person operator +(Person &p1,Person &p2)//返回的是一个Person类,传入一个person类的引用，地址传递
{
	Person temp；
	temp.m_A = this->m_A + p.m_A; //使用this指针解决 名字冲突
	temp.m_B = this->m_B + p.m_B;
	return temp;
}
//全局函数重载本质调用
Person p3 = operator+(p1, p2);
Person p3 = p1 + p2;//简化形式

//函数重载版本实现 p4 = p1 + int 类型
Person operator+(Person &p1, int num)
{
	Person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}
Person p4 = p1 + 100;

左移运算符重载

作用：可以输出自定义数据类型

class Person
{
public:

	//利用成员函数重载 左移运算符
	//不会利用成员函数重载<<运算符，因为无法实现cout在左侧
	void operator<<(Person)
	int m_A;
	int m_B;
};
//只能利用全局函数重载左移运算符
void operator<<(ostream &cout ,Person &p)  //本质
{
	cout << "m_A = "<<p.m_A << "m_B = " <<p.m_B;
}

void test01()
{
	Person p;
	p.m_A = 10;
	p.m_B = 10;

	cout << p ;
}

递增运算符重载

作用：通过重载运算符，实现自己的整型数据

class MyInteger
{
friend ostream &operator<<(ostream& cout , MyInteger myint)
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符
	MyInteger& operator++() //返回引用是为了一直对一个数据进行递增操作
	{
		//先进行++运算
		m_Num++;
		//再将自身返回
		return *this;
	}
	//重载后置++运算符 ，返回的是值，区别于前置
	MyInterger operator++(int)//int 代表占位参数，可以用于区分前置和后置递增
	{
		//先 记录当时结果
		MyInteger temp = *this;
		//后 递增
		m_Num++;
		//z最后将记录结果做返回
		return temp;
	}
	private:
	int m_Num;
};
//重载左移<<运算符
ostream &operator<<(ostream& cout , MyInteger myint)
{
	cout << myint.m_Num;
	return cout;
}

void test01()
{
	MyInteger myint;
	cout << ++(++myint) << endl; //输出 2
	cout << myint <<endl; //输出2
}
void test02()
{
	MyInteger myint;
	cout << myint++ <<endl;
	cout << myint << endl;
}
int main()
{
	test01();
}

赋值运算符重载

C++编译器至少给一个类添加4个函数：
1、默认构造函数（无参，函数体为空）
2、默认析构函数（无参，函数体为空）
3、默认拷贝构造函数，对属性进行拷贝
4、赋值运算符 operator = ，对属性进行值拷贝

继承

继承是面向对象三大特性之一
有些类与类之间存在特殊的关系，例如：
在这里插入图片描述

继承的基本用法

继承的优点：减少重复代码
语法：

class 子类 : 继承方式 父类

子类也称为派生类、父类称为基类

举个例子：

class Java
{
public:
	void header()
	{
		cout<< "首页、公开课、登录、注册...(公共头部)"<<endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)"<<endl;
	}
	void left()
	{
		cout<<"Java、Python、C++...(公共分类列表)"<< endl;
	}
	void content()
	{
		cout << "Java学科视频"<< endl;
	}
};
//Python页面
class Python
{
public:
	void header()
	{
		cout<< "首页、公开课、登录、注册...(公共头部)"<<endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)"<<endl;
	}
	void left()
	{
		cout<<"Java、Python、C++...(公共分类列表)"<< endl;
	}
	void content()
	{
		cout << "Python学科视频"<< endl;
	}
};
class CPP
{
public:
	void header()
	{
		cout<< "首页、公开课、登录、注册...(公共头部)"<<endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)"<<endl;
	}
	void left()
	{
		cout<<"Java、Python、C++...(公共分类列表)"<< endl;
	}
	void content()
	{
		cout << "C++学科视频"<< endl;
	}
};
void test01()
{
	cout<<"Java下载视频页面如下："<<endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout<< "---------------"<<endl;	
	cout<<"Python下载视频页面如下："<<endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout<< "---------------"<<endl;
	cout<<"C++下载视频页面如下："<<endl;
	CPP cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();
	cout<< "---------------"<<endl;
}

上述代码实现方法过于繁琐，效率低，为了简洁代码和提高效率，可以用继承的方法实现页面

class BasePage
{
//每个类的公共部分不变
public:
	void header()
	{
		cout<< "首页、公开课、登录、注册...(公共头部)"<<endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)"<<endl;
	}
	void left()
	{
		cout<<"Java、Python、C++...(公共分类列表)"<< endl;
	}
class Java : public BasePage
{
public:
	void content()
	{
		cout << "Java学科视频"<< endl;
	}
};
class Python : public BasePage
{
public:
	void content()
	{
		cout << "Python学科视频"<< endl;
	}
};
class CPP : public BasePage
{
public:
	void content()
	{
		cout << "cpp学科视频"<< endl;
	}
};
};

继承方式

继承的语法class 子类 : 继承方式父类

继承方式一共有三种：

公共继承
保护继承
私有继承

父类中的私有成员，三种继承方式都不可访问
公有继承父类中的公共权限成员和保护权限成员不变
保护继承父类中的公共权限成员和保护权限成员都变成保护权限成员
私有继承父类中的公共权限成员和保护权限成员都变成私有权限成员
在这里插入图片描述

class Base1
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
//公共继承
class Son1 : public Base1
{
public:
	void func()
	{
		m_A = 10; //父类中公共权限成员 到子类中仍然是公共权限
		m_B = 10; //父类中保护权限成员 到子类中仍然是保护权限
		m_C = 10; //父类中私有权限成员 子类访问不到
	}
};

void test01()
{
	Son1 s1;
	s1.m_A = 100;
	//s1.m_B = 100; 到Son1中 m_B是保护权限 类外访问不到
}

class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2 : protected Base2
{
public:
	void func()
	{
		m_A = 10; //父类中公共权限成员 到子类中是保护权限
		m_B = 10; //父类中保护权限成员 到子类中仍然是保护权限
		m_C = 10; //父类中私有权限成员 子类访问不到
	}
};

继承中的对象模型

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son1 : public Base1
{
public:
	int m_D;
};

void test01()
{
	cout << "size of Son = " << sizeof(Son) << endl; //输出结果为16
	//在父类中所有非静态成员属性都会被子类继承下去
	//父类中私有成员属性 是被编译器隐藏了，因此是访问不到，但却是被继承下去了
}

继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造和析构顺序是谁先谁后？

class Base
{
public:
	Base()
	{
		cout << "Base构造函数!" <<endl;
	}
	~Base()
	{
		cout << "Base析构函数!" <<endl;
	}
};
class Son1 : public Base1
{
public:
	Son()
	{
		cout << "Son构造函数!" <<endl;
	}
	~Son()
	{
		cout << "Son析构函数!" <<endl;
	}
};
void test01()
{
	//Base b;
	Son s; 
	//会先构造父类，再构造子类，析构顺序和构造顺序相反
}

继承同名成员处理方式

问题：当子类与父类出现同名成员，如何通过子类对象，访问到子类或父类中同名的数据？

访问子类同名成员直接访问即可
访问父类同名成员需加作用域
当子类与父类拥有同名的成员函数，子类会隐藏父类中的同名成员函数，加作用域可以访问到父类中同名函数

class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "Base - func()调用"<< endl;
	}
	void func(int a)
	{
		cout << "Base - func()调用"<< endl;
	}
	int m_A;
};
class Son : public Base
{
public:
	Son()
	{
		m_A = 200;
	}
		void func()
	{
		cout << "Son - func()调用"<< endl;
	}
	int m_A;
};
void test01()
{
	Son s;
	cout << "Son 下 m_A = "<<s.m_A << endl; 
	//如果通过子类对象访问到父类中同名成员 ， 需要加作用域
	cout << "Base 下 m_A = "<<s.Base::m_A << endl;  
}

//同名成员函数处理
void test02()
{
	Son s;
	// 直接调用 调用的是子类中的同名成员
	s.func();
	//如何直接调用父类中同名成员函数
	s.Base :: func();
	//如果子类中出现和父类同名的成员函数，子类中的同名成员会隐藏掉父类中所有同名成员函数
	//如果想访问到父类中被隐藏的成员函数，需要加作用域
	s.Base::func(100);
}

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

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

访问子类同名成员，直接访问即可
访问父类同名成员需要加作用域

多继承语法

C++允许一个类继承多个类
语法：class 子类 : 继承方式父类1 , 继承方式父类2 ...
多继承可能会引发父类中有同名成员出现，需要加作用域区分
C++实际开发中不建议用多继承

多态

多态的优点：

代码组织结构清晰
可读性强
利于前期和后期的扩展以及维护

多态的基本概念

多态是C++面向对象三大特性之一
多态分为两类：

静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态的区别：

静态多态的函数地址早绑定 - 编译阶段确定函数地址
动态多态的函数地址晚绑定 - 运行阶段确定函数地址

案例：

class Animal
{
public:
	virtual void speak() //虚函数 ，加了virtual才能满足晚绑定
	{
		cout << "动物在说话" << endl;
	}

};

class Cat : public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}

};

class Dog : public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}

};

//执行说话的函数
//地址早绑定  在编译阶段就确定了函数地址，会执行父类中的speak
//如果想执行让猫说话，那么这个地址就不能提前绑定，需要在运行阶段进行绑定
void doSpeak(Animal& animal) //Animal &animal = cat;
{
	animal.speak();
}

void test01()
{
	Cat cat;
	doSpeak(cat);

	Dog dog;
	doSpeak(dog);

}

int main()
{
	test01();
	return 0;
	system("pause");
}

动态多态满足条件：
1、有继承关系
2、子类重写父类中的虚函数（区别于重载，重载是函数名相同但参数不同）
重写：函数返回值类型、函数名、参数列表完全相同

动态多态使用

父类的指针或者引用指向子类对象

多态深入剖析

虚函数相当于定义了一个虚函数指针vfptr 指向内部的一个 vftable虚函数表
当子类继承了父类，同时也继承了虚函数指针指向自己内部的一个虚函数表
当子类重写父类的虚函数时，子类中的虚函数表内部会替换成子类的虚函数地址
当父类的指针或引用指向子类对象时，发生多态
在这里插入图片描述

纯虚函数和抽象类

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

纯虚函数语法virtual 返回值类型函数名（参数列表）= 0

当类中有了这个纯虚函数，这个类也成为抽象类

抽象类特点：

无法实例化对象
子类必须重写抽象类中的纯虚函数，否则也属于抽象类

//纯虚函数和抽象函数
class Base
{
public:

	//纯虚函数
	//只要有一个纯虚函数，这个类称为抽象类
	//抽象类特点：1、无法实例化对象
			//2、抽象类的子类 必须要重写父类中的纯虚函数，否则也属于抽象类
	virtual void func() = 0;  //纯虚函数
};

class Son :public Base
{
	virtual void func()
	{
		cout << "func 函数调用" << endl;
	}
};
void test01()
{
	Base* base = new Son; //new 一个 Son的对象接收base的类指针
	base->func();
}

虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方法：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

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

虚析构和纯虚析构区别：

如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：
virtual ~类名() {}

纯虚析构语法：
virtual ~类名() = 0;
类名::~类名( ) { }

//虚析构和纯虚析构
class Animal
{
public:

	Animal()
	{
		cout << "Animal构造函数调用" << endl;
	}

	//利用虚析构可以解决 父类指针释放子类对象时不干净的问题
	/*virtual ~Animal()
	{
		cout << "Animal析构函数调用" << endl;
	}*/
	// 纯虚析构 需要声明和代码实现
	virtual ~Animal() = 0; 
	virtual void speak() = 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()
	{
		if (m_Name != NULL)
		{
			cout << "Cat析构函数调用" << endl;
			delete m_Name;
			m_Name = NULL;
		}
	}
	string* m_Name;
};

void test01()
{
	//使用了父类的指针指向子类的对象
	//所以delete的时候不会走子类的析构代码
	//导致堆区没有释放干净，造成内存泄露
	Animal* animal = new Cat("Tom"); 
	animal->speak();
	delete animal;
}

int main()
{ 
	test01();
	system("pause");
	return 0;
}

总结：
1、虚析构或纯虚析构就是用来解决通过父类释放子类对象
2、如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
3、拥有纯虚析构函数的类也属于抽象类

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)