C++ 基础【14】

于 2020-11-30 18:13:30 发布
阅读量118 收藏
点赞数
分类专栏： C++ 笔记 文章标签： c++ 多态 抽象类 虚函数 纯虚函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44111597/article/details/110394011
版权

本文代码仓库地址： gitee码云CSDN笔记仓库地址

目录

多态的基本概念【Class26】

// 多态 -- 多态的基本概念
/*
* 静态多态：函数重载 和 运算符重载 都属于静态多态，重复的使用同名的函数
* 动态多态：派生类和虚函数实现运行时多态
* 
* 静态多态与动态多态的区别：
* 静态多态的函数地址早绑定 - 编译阶段确定函数地址
* 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
* 
* 动态多态的满足条件：
* 1、需要有继承关系
* 2、子类要重写父类的虚函数【重写（也是需要有继承关系的存在）：函数返回值、函数名和函数参数完全相同的】
* 
* 动态多态的使用：父类的指针或者引用来执行子类的对象
*/
#include <iostream>

using namespace std;


// 动物类 -- 父类
class mClass01_xy {
public:
	// 动物说话 -- 普通函数
	void mFun01() {
		cout << "动物在说话01" << endl;
	}

	// 动物说话 -- 虚函数
	virtual void mFun02() {
		cout << "动物在说话02" << endl;
	}
};

// 狗类 -- 继承动物类 -- 子类
class mClass0101_xy :public mClass01_xy {
public:
	// 狗在汪汪叫1
	void mFun01() {
		cout << "小狗在说话01" << endl;
	}

	// 狗在汪汪叫2【子类的 virtual 可写可不写，下面的猫类中就没有写】
	virtual void mFun02() {
		cout << "小狗在说话02" << endl;
	}
};

// 猫类 -- 继承动物类 -- 子类
class mClass0102_xy :public mClass01_xy {
public:
	// 猫在喵喵叫1
	void mFun01() {
		cout << "小猫在说话01" << endl;
	}

	// 猫在喵喵叫2
	void mFun02() {
		cout << "小猫在说话02" << endl;
	}
};

// 动物在说话的行为1实现【这种是属于地址早绑定，在编译阶段确定函数地址】
void mSpeak1(mClass01_xy& speak) {
	speak.mFun01();
}

// 动物在说话的行为2实现【这种是属于地址晚绑定，在运行阶段确定函数地址】
void mSpeak2(mClass01_xy& speak) {
	speak.mFun02();
}

void fun01() {
	mClass0101_xy dog1;
	// 这里我的目的是想让小狗说话
	mSpeak1(dog1);
	mSpeak2(dog1);
	mClass0102_xy cat1;
	mSpeak1(cat1);
	mSpeak2(cat1);
}


int main() {

	fun01();
	cout << "------------------分界线------------------" << endl;

	cout << endl;
	system("pause");
	return 0;
}

多态的原理剖析【Class27】

// 多态 -- 多态的原理剖析
#include <iostream>

using namespace std;


// 动物类01 -- 父类【cl /d1 reportSingleClassLayoutmClass01_xy "Main.cpp"】-- 图0
class mClass01_xy {
public:
	// 普通函数
	void mFun01() {	}
};

// 动物类02 -- 父类【cl /d1 reportSingleClassLayoutmClass02_xy "Main.cpp"】-- 图1
class mClass02_xy {
public:
	// 虚函数
	virtual void mFun02() {	}
};

// 狗类01 -- 继承动物类01 -- 子类【cl /d1 reportSingleClassLayoutmClass0101_xy "Main.cpp"】-- 图2
class mClass0101_xy :public mClass01_xy {
public:
	void mFun01() {	}
};

// 猫类01 -- 继承动物类02 -- 子类【cl /d1 reportSingleClassLayoutmClass0201_xy "Main.cpp"】-- 图3
class mClass0201_xy :public mClass02_xy {
public:
	void mFun02() {	}
};

// 狗类02 -- 继承动物类01 -- 子类【cl /d1 reportSingleClassLayoutmClass0102_xy "Main.cpp"】-- 图4
class mClass0102_xy :public mClass01_xy { };

// 猫类02 -- 继承动物类02 -- 子类【cl /d1 reportSingleClassLayoutmClass0202_xy "Main.cpp"】-- 图5
class mClass0202_xy :public mClass02_xy { };


void fun01() {
	// 类中的成员函数是普通的成员函数，this类占一个字节
	cout << "mClass01_xy 所占内存大小为：" << sizeof(mClass01_xy) << endl;
	// 类中的成员函数是虚函数，this类占四个字节
	cout << "mClass02_xy 所占内存大小为：" << sizeof(mClass02_xy) << endl;
	cout << endl;
	cout << "mClass0101_xy 所占内存大小为：" << sizeof(mClass0101_xy) << endl;
	cout << "mClass0201_xy 所占内存大小为：" << sizeof(mClass0201_xy) << endl;
	cout << endl;
	cout << "mClass0102_xy 所占内存大小为：" << sizeof(mClass0102_xy) << endl;
	cout << "mClass0202_xy 所占内存大小为：" << sizeof(mClass0202_xy) << endl;
}


int main() {

	fun01();
	cout << "------------------分界线------------------" << endl;

	cout << endl;
	system("pause");
	return 0;
}

图0：
在这里插入图片描述
图1：
在这里插入图片描述
图2：
在这里插入图片描述
图3：
在这里插入图片描述
图4：
在这里插入图片描述
图5：
在这里插入图片描述

案例1：两个整数加减乘的计算器功能的实现【Class28】

// 多态 -- 案例1：两个整数加减乘的计算器功能的实现
/*
* 多态的特点：
* 1、要有继承
* 2、要有重写
* 3、父类引用或指针指向子类对象
* 
* 多态的优点：
* 1、结构清晰
* 2、可读性强
* 3、易扩充性
* 
* 多态的缺点：不能使用子类特有的功能
*/
#include <iostream>

using namespace std;


// 计算器的抽象类 -- 父类
class mClass01_xy {
public:
	// 抽象类中任何的功能都不写
	// 参数1
	int num1;
	// 参数2
	int num2;

	// 无参构造函数设初值
	mClass01_xy() {	
		num1 = 0;
		num2 = 0;
	}

	// 这是计算用的虚函数
	virtual int mFun01() {
		return 0;
	}
};

// 加法计算 -- 子类
class mClass0101_xy :public mClass01_xy {
public:
	// 重写父类中的虚函数
	virtual int mFun01() {
		return num1 + num2;
	}
};

// 减法计算 -- 子类
class mClass0102_xy :public mClass01_xy {
public:
	// 重写父类中的虚函数
	virtual int mFun01() {
		return num1 - num2;
	}
};

// 乘法计算 -- 子类
class mClass0103_xy :public mClass01_xy {
public:
	// 重写父类中的虚函数
	virtual int mFun01() {
		return num1 * num2;
	}
};

// 两个数写死的运算
void fun01() {
	// 父类指针指向子类对象
	mClass01_xy* mC01 = new mClass0101_xy;
	mC01->num1 = 10;
	mC01->num2 = 10;
	cout << mC01->num1 << " + " << mC01->num2 << " = " << mC01->mFun01() << endl;
	// 自己 new 的对象在堆区 需要我们自己手动释放
	delete mC01;
	// 这里可以直接使用 mC01 进行重新指向，因为前面虽然已经释放了 mC01，但是其类型还是 mClass01_xy*，相当于重新赋值了
	mC01 = new mClass0102_xy;
	mC01->num1 = 20;
	mC01->num2 = 10;
	cout << mC01->num1 << " - " << mC01->num2 << " = " << mC01->mFun01() << endl;
	delete mC01;
	mC01 = new mClass0103_xy;
	mC01->num1 = 20;
	mC01->num2 = 10;
	cout << mC01->num1 << " * " << mC01->num2 << " = " << mC01->mFun01() << endl;
}


int main() {

	fun01();
	cout << "------------------分界线------------------" << endl;

	cout << endl;
	system("pause");
	return 0;
}

纯虚函数和抽象类【Class29】

// 多态 -- 纯虚函数和抽象类
/*
* 当类中只要有一个纯虚函数，这个类就称为抽象类
* 纯虚函数语法：virtual 返回值 函数名(参数列表) = 0;
*              virtual int mFun01() = 0;
* 
* 抽象类特点：
* 1、无法实例对象
* 2、子类必须重写抽象类中的纯虚函数，否则子类也属于抽象类
*/
#include <iostream>

using namespace std;


// 当类中只要有一个纯虚函数，这个类就称为抽象类
class mClass01_xy {
public:

	// 纯虚函数
	virtual int mFun01() = 0;

};

// 子类中不重写父类中的纯虚函数
class mClass0101 :public mClass01_xy {
public:

};

// 子类中重写父类中的纯虚函数
class mClass0102 :public mClass01_xy {
public:


	virtual int mFun01() {
		cout << "我重写了父类--抽象类" << endl;
		return 0;
	}
};

void fun01() {
	// 抽象类无法实例化对象
	// mClass01_xy mc;
	/* mClass01_xy* mc;
	   mc = new mClass01_xy; */
	// 子类没有重写父类中的纯虚函数，子类也变成了纯虚函数
	// mClass0101 mc;
	// mClass01_xy* mc2 = new mClass0101;
	mClass0102 mc1;
	mc1.mFun01();
	mClass01_xy* mc2 = new mClass0102;
	mc2->mFun01();
	delete mc2;
}


int main() {

	fun01();
	cout << "------------------分界线------------------" << endl;

	cout << endl;
	system("pause");
	return 0;
}

案例2：人人是大厨【Class30】

// 多态 -- 案例2：人人是大厨
#include <iostream>

using namespace std;


// 做菜额抽象类
class mClass01_xy {
public:
	// 锅烧到冒烟
	virtual void mFun01() = 0;

	// 油搞里头
	virtual void mFun02() = 0;

	// 菜搞里头
	virtual void mFun03() = 0;

	// 翻炒几哈
	virtual void mFun04() = 0;

	// 作料搞里头
	virtual void mFun05() = 0;

	// 再翻炒几哈
	virtual void mFun06() = 0;

	// 出锅
	virtual void mFun07() = 0;

	// 一键炒菜
	virtual void mFun08() {
		mFun01();
		mFun02();
		mFun03();
		mFun04();
		mFun05();
		mFun06();
		mFun07();
	}

};

// 青椒土豆丝
class mClass0101 :public mClass01_xy {
public:
	virtual void mFun01() {
		cout << "锅烧冒烟" << endl;
	}

	virtual void mFun02() {
		cout << "油搞里头" << endl;
	}

	virtual void mFun03() {
		cout << "土豆丝、青椒搞锅里头" << endl;
	}

	virtual void mFun04() {
		cout << "翻炒几哈" << endl;
	}

	virtual void mFun05() {
		cout << "搞点盐、鸡精" << endl;
	}

	virtual void mFun06() {
		cout << "再翻炒几哈" << endl;
	}

	virtual void mFun07() {
		cout << "出锅！！！" << endl;
	}

};

// 清炒小白菜
class mClass0102 :public mClass01_xy{
public:
	virtual void mFun01() {
		cout << "锅烧冒烟" << endl;
	}

	virtual void mFun02() {
		cout << "油搞里头" << endl;
	}

	virtual void mFun03() {
		cout << "小白菜搞锅里头" << endl;
	}

	virtual void mFun04() {
		cout << "翻炒几哈" << endl;
	}

	virtual void mFun05() {
		cout << "搞点盐、鸡精" << endl;
	}

	virtual void mFun06() {
		cout << "再翻炒几哈" << endl;
	}

	virtual void mFun07() {
		cout << "出锅！！！" << endl;
	}

};

// 一键炒菜功能
void mGoodGood(mClass01_xy* abs) {
	abs->mFun08();
	delete abs;
}

void fun01() {
	// 先抄个青椒土豆丝
	mGoodGood(new mClass0101);
	cout << endl;
	// 再抄个小白菜
	mGoodGood(new mClass0102);
}


int main() {

	fun01();
	cout << "------------------分界线------------------" << endl;

	cout << endl;
	system("pause");
	return 0;
}

一点点笔记，以便以后翻阅。

小印丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小印丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值