c++学习---第四部分下

已于 2022-08-21 22:26:14 修改
阅读量390 收藏
点赞数
分类专栏： c++学习 文章标签： c++ 学习 java
于 2022-08-21 22:25:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/charles_zhang_/article/details/126456573
版权
本文详细讲解了C++中的继承和多态特性。包括继承的三种方式（公共、保护、私有），对象模型，构造和析构顺序，同名成员处理，静态成员处理，多继承与菱形继承问题及解决方案。接着介绍了多态的基本概念，动态多态的实现，如计算器类的重构，以及多态在计算器和饮品制作中的应用。强调了虚函数和纯虚函数在实现抽象类和多态中的作用，并通过电脑组装案例展示了多态在实际问题中的应用。
摘要由CSDN通过智能技术生成

第四部分-继承和多态

4.6、继承

image-20220812214925300

1、继承的基本语法

image-20220812215059142

image-20220812220929498

image-20220812221021748

2、继承方式*

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

继承方式一共有三种：

公共继承

保护继承

私有继承

image-20220812221250975

3、继承中的对象模型

**问题：**从父类继承过来的成员，那些属于子类对象中？

image-20220812223807136

image-20220812223826712

**结论：**父类中私有成员也是被子类继承下去，只是由编译器给隐藏后访问不到

4、继承中构造和析构的顺序

image-20220812224003607

image-20220812224428514

总结：继承中 先调用父类构造函数，在调用子类构造函数，析构顺序与构造相反

5、继承同名成员处理方式

image-20220813214412538

image-20220813215351678

image-20220813215418272

总结:

1、子类对象可以直接访问到子类中同名成员

2、子类对象加作用域可以访问到父类同名成员

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

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

image-20220813215759567

image-20220813221438152

image-20220813221452314

image-20220813221521276

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象和通过类名）

7、多继承语法

image-20220813221729613

image-20220813222034167

image-20220813222101455

image-20220813222130274

总结：多继承中如果父类出现了同名情况，子类使用时候要加作用域

8、菱形继承

image-20220813222358215

image-20220813222417101

image-20220813222527479

vbptr解释

image-20220813223516776

代码演示

image-20220813223629644

总结：

菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义

利用虚继承可以解决零星继承问题

4.7、多态

1、多态的基本概念

image-20220818220255823

image-20220818221846819

image-20220818221925298

image-20220818221945719

#include <iostream>
using namespace std;

//多态
//动物类
class Animal {
public:
	//虚函数
	virtual void speak() {
		cout << "动物在说话" << endl;
	}
};

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


//执行说话的函数
//地址早绑定  在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定

//动态多台满足条件
//1、有继承关系
//2、子类重写父类的虚函数

//动态多态使用
// 父类的指针或者引用执行子类对象

void doSpeak(Animal &animal) {// Animal & animal = cat;
	animal.speak();
}

void test01() {
	//重写 函数返回值类型  函数名  参数列表  完全相同
	Cat cat;
	doSpeak(cat);
}

void test02() {
	cout << "sizeof Animal = " << sizeof(Animal) << endl;
}

int main() {
	//test01();
	test02();
}

image-20220818221958751

内存指针层面的解释

image-20220818223926380

2、多态案例一、计算器类

image-20220819222336350

#include<iostream>
using namespace std;
#include<string>

//普通写法
class Calculator {
public:

	int getResult(string oper) {
		if (oper == "+") {
			return m_Num1 + m_Num2;
		}
		if (oper == "-") {
			return m_Num1 - m_Num2;
		}
		if (oper == "*") {
			return m_Num1 * m_Num2;
		}
		if (oper == "/") {
			return m_Num1 / m_Num2;
		}
		//如果想扩展新的功能，需求修改源码
		//在真是开发中 提倡  开闭原则
		//开闭原则：对扩展进行开发，对修改进行关闭
	}
	int m_Num1;
	int m_Num2;
};

void test01() {
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 10;

	cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl;
	cout << c.m_Num1 << "-" << c.m_Num2 << "-" << c.getResult("-") << endl;
	cout << c.m_Num1 << "*" << c.m_Num2 << "*" << c.getResult("*") << endl;
	cout << c.m_Num1 << "/" << c.m_Num2 << "/" << c.getResult("/") << endl;

}

//利用多态实现计算器
//实现计算器抽象类
//1、组织结构清晰
//2、可读性强
//3、对于前期和后期扩展以及维护性高
class AbstractCaculator {
public:
	virtual int getResult(){
		return 0;
	}
	
	int m_Num1;
	int m_Num2;
};


//加法计算器类
class AddCalculator : public AbstractCaculator {
public:
	int getResult() {
		return m_Num1 + m_Num2;
	}
};

class SubCalculator : public AbstractCaculator {
public:
	int getResult() {
		return m_Num1 - m_Num2;
	}
};

class MulCalculator : public AbstractCaculator {
public:
	int getResult() {
		return m_Num1 * m_Num2;
	}
};

void test02() {
	//多态使用
	//父类指针或者引用指向子类对象

	//加法对象
	AbstractCaculator* abs = new AddCalculator;
	abs->m_Num1 = 10;
	abs->m_Num2 = 10;
	cout << abs->m_Num1 << "+" << abs->m_Num2 << "=" << abs->getResult() << endl;
	//用完记得销毁
	delete abs;

	//减法运算
	abs = new SubCalculator;
	abs->m_Num1 = 10;
	abs->m_Num2 = 10;
	cout << abs->m_Num1 << "-" << abs->m_Num2 << "=" << abs->getResult() << endl;
	delete abs;

	//乘法运算
	abs = new MulCalculator;
	abs->m_Num1 = 10;
	abs->m_Num2 = 10;
	cout << abs->m_Num1 << "*" << abs->m_Num2 << "=" << abs->getResult() << endl;
	delete abs;
}
int main() {
	//test01();
	test02();
}

总结：c++开发提倡利用多态设计程序架构，因为多态优点很多

3、纯虚函数和抽象类

image-20220821210622117

image-20220821211030571

image-20220821211047849

4、多态案例二-制作饮品

image-20220821211124898

代码

#include<iostream>
using namespace std;

//制作饮品
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 doWork(AbstractDrinking * abs) { //AbstractDrinking * abs = new Caffee
	abs->makeDrink();
	delete abs;//释放
}


void test01() {
	doWork(new Coffee);
	cout << "--------------" << endl;
	doWork(new Tea);
}

int main() {
	test01();
}

5、虚析构和纯虚析构

image-20220821212447447

image-20220821214332438

#include<iostream>
using namespace std;
#include<string>

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

	string* m_Name;
};

void test01() {
	Animal* animal = new Cat("TOM");
	animal->speak();
	//父类指针在析构时候 不会调用子类中析构函数  导致子类对象可能清理不干净，造成内存泄露
	//怎么解决？基类怎加一个虚析构函数
	//析构函数就是用来解决通过父类指针释放子类对象
	delete animal;
}

int main() {
	test01();
}

image-20220821214534028

6、多态案例三-电脑组装

image-20220821214623766

案例分析

image-20220821215655132

代码实现

#include<iostream>
using namespace std;

//抽象不同零件类
//抽象cpu类
class CPU {
public:
	virtual void calculat() = 0;
};

//抽象显卡类
class VideoCard {
public:
	virtual void display() = 0;
};

//抽象内存条类
class Memory {
public:
	virtual void storage() = 0;
};

//电脑类
class Computer {
public:
	Computer(CPU* cpu, VideoCard* vc, Memory* mem) {
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
	}

	void work() {
		m_cpu->calculat();

		m_vc->display();

		m_mem->storage();
	}

	//提供一个析构函数释放三个电脑的零件
	~Computer() {
		//释放cpu
		if (m_cpu != NULL) {
			delete m_cpu;
			m_cpu = NULL;
		}
		//释放显卡
		if (m_vc != NULL) {
			delete m_vc;
			m_vc = NULL;
		}
		//释放内存
		if (m_mem != NULL) {
			delete m_mem;
			m_mem = NULL;
		}
	}



private:
	CPU* m_cpu;//CPU零件指针
	VideoCard* m_vc;//显卡零件指针
	Memory* m_mem;//内存条零件指针
};

//具体厂商
//Inter厂商
class InterCPU : public CPU {
public:
	virtual void calculat() {
		cout << "Inter的CPU开始计算了" << endl;
	}
};

class InterVideoCard : public VideoCard {
public:
	virtual void display() {
		cout << "Inter的显卡开始显示了" << endl;
	}
};

class InterMemory : public Memory {
public:
	virtual void storage() {
		cout << "Inter的内存条开始存储了" << endl;
	}
};

//Lenovo厂商
class LenovoCPU : public CPU {
public:
	virtual void calculat() {
		cout << "Lenovo的CPU开始计算了" << endl;
	}
};

class LenovoVideoCard : public VideoCard {
public:
	virtual void display() {
		cout << "Lenovo的显卡开始显示了" << endl;
	}
};

class LenovoMemory : public Memory {
public:
	virtual void storage() {
		cout << "Lenovo的内存条开始存储了" << endl;
	}
};

void test01() {
	//第一台电脑的零件
	CPU* interCpu = new InterCPU;
	VideoCard* interCar = new InterVideoCard;
	Memory* interMem = new InterMemory;

	//创建第一台电脑
	Computer* computer1 = new Computer(interCpu, interCar, interMem);
	computer1->work();
	delete computer1;

	cout << "----------" << endl;
	cout << "第二台开始工作" << endl;
	//创建第二台电脑
	Computer* computer2 = new Computer(new LenovoCPU,new LenovoVideoCard,new LenovoMemory);
	computer2->work();
	delete computer2;

	cout << "----------" << endl;
	cout << "第三台开始工作" << endl;
	//创建第二台电脑
	Computer* computer3 = new Computer(new InterCPU, new LenovoVideoCard, new LenovoMemory);
	computer3->work();
	delete computer3;
}

int main() {
	test01();

}
麻花地
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值