c++（六）

最新推荐文章于 2024-11-08 15:01:00 发布
最新推荐文章于 2024-11-08 15:01:00 发布
阅读量994 收藏 9
点赞数 26
分类专栏： c++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuezhe_____/article/details/139301605
版权

c++（六）


在这里插入图片描述

多态

概念

多种状态（一个事物的多种状态或形态）

<1>水在不同的温度下呈现的不同状态
<2>买票
学生票；
成人票；
老年票；
军人；

在c++中是如何实现多态

绑定：就是把函数调用语句与对应的代码块进行了绑定！。

静态多态（绑定）

在编译的时候，就知道执行的是哪一个函数体
调用函数时，函数名是一样的，当我们传入不同参数的时候，执行的是不同的函数体（函数重载、运算符重载）

动态多态（绑定）

在运行的时候，才知道执行的是哪一个函数体

案例：如果要求两个子类的周长和面积之和，就得写两个函数来实现，传入不同的对象
在这里插入图片描述

在这里插入图片描述

#include <iostream>
using namespace std;
class Shape
{
public:
	Shape(int s = 0, int c = 0) :s(s), c(c)
	{
		cout << "Shape构造" << endl;
	}
	~Shape()
	{
		cout << "Shape析构" << endl;
	}
	int getC()
	{
		cout << "周长：" << this->c << endl;
		return this->c;
	}
	int getS()
	{
		cout << "面积：" << this->s << endl;
		return this->s;
	}
private:
protected:
	int s;
	int c;
};
class Rect:public Shape
{
public:
	Rect(int a = 0, int b = 0) :a(a), b(b)
	{
		cout << "Rect构造" << endl;
	}
	~Rect()
	{
		cout << "Rect析构" << endl;
	}
	int getC()
	{
		this->c = (this->a + this->b) * 2;
		return this->c;
	}
	int getS()
	{
		this->s = this->a * this->b;
		return this->s;
	}
	void show()
	{
		cout << "周长：" << this->c << ",面积：" << this->s << endl;
	}
private:
protected:
	int a;
	int b;
};
class Circle:public Shape
{
public:
	Circle(int r = 0) :r(r)
	{
		cout << "Circle构造" << endl;
	}
	~Circle()
	{
		cout << "Circle析构" << endl;
	}
	int getC()
	{
		this->c = 2 * 3.14 * this->r;
		return this->c;
	}
	int getS()
	{
		this->s = 3.14 * this->r * this->r;
		return this->s;
	}
	void show()
	{
		cout << "周长：" << this->c << ",面积：" << this->s << endl;
	}
private:
protected:
	int r;
};
void Rcs(Rect & demo)
{
	cout << demo.getC()+ demo.getS()<< endl;
}
void Ccs(Circle& demo)
{
	cout << demo.getC() + demo.getS() << endl;
}
int main()
{
	//矩形对象
	Rect rect(2,3);
	Rcs(rect);
	
	//圆形对象
	Circle circle(3);
	Ccs(circle);


}

解决：用父类统一管理子类
在这里插入图片描述
问题：通过父类的引用操作子类的对象时，并没有执行子类的函数，执行的是子类从父类继承过来的函数
在这里插入图片描述
解决：目的：执行子类重定义的函数，将父类对应的函数写成虚函数
虚函数的格式：

virtual 返回值类型 函数名(参数列表){}

未加victual之前，不能访问子类重定义函数的原因：
将子类对象强制赋值给父类的引用，父类的引用所访问的范围小，访问不到子类的函数
在这里插入图片描述

#include <iostream>
using namespace std;
class Shape
{
public:
	Shape(int s = 0, int c = 0) :s(s), c(c)
	{
		cout << "Shape构造" << endl;
	}
	~Shape()
	{
		cout << "Shape析构" << endl;
	}
	virtual int getC()
	{
		cout << "周长：" << this->c << endl;
		return this->c;
	}
	virtual int getS()
	{
		cout << "面积：" << this->s << endl;
		return this->s;
	}
private:
protected:
	int s;
	int c;
};
class Rect:public Shape
{
public:
	Rect(int a = 0, int b = 0) :a(a), b(b)
	{
		cout << "Rect构造" << endl;
	}
	~Rect()
	{
		cout << "Rect析构" << endl;
	}
	int getC()
	{
		this->c = (this->a + this->b) * 2;
		return this->c;
	}
	int getS()
	{
		this->s = this->a * this->b;
		return this->s;
	}
	void show()
	{
		cout << "周长：" << this->c << ",面积：" << this->s << endl;
	}
private:
protected:
	int a;
	int b;
};
class Circle:public Shape
{
public:
	Circle(int r = 0) :r(r)
	{
		cout << "Circle构造" << endl;
	}
	~Circle()
	{
		cout << "Circle析构" << endl;
	}
	int getC()
	{
		this->c = 2 * 3.14 * this->r;
		return this->c;
	}
	int getS()
	{
		this->s = 3.14 * this->r * this->r;
		return this->s;
	}
	void show()
	{
		cout << "周长：" << this->c << ",面积：" << this->s << endl;
	}
private:
protected:
	int r;
};
void Scs(Shape & demo)
{
	cout << demo.getC()+ demo.getS()<< endl;
}
int main()
{
	//矩形对象
	Rect rect(2,3);
	Scs(rect);
	
	//圆形对象
	Circle circle(3);
	Scs(circle);


}

在这里插入图片描述

动态多态的实现原理

有虚函数一定能实现动态多态吗？不一定

多态的实现：
<1>一个父类，有多个子类
<2>父类中有虚函数，子类重写父类的虚函数
<3>用父类对象的指针或者引用去操作子类的对象并调用虚函数的受，才会触发动态多态（决定性因素）

将父类的对应的函数写成虚函数，在子类中进行重写，通过父类对象的指针/引用去操作子类对象就可以调用到子类的函数了

指针所能访问的空间的大小：由指针指向的数据类型大小决定

int *p; //4字节
shape *p;// 8个字节

在这里插入图片描述
为什么添加virtual就可以访问子类的函数？

虚函数表：保存虚函数的地址（函数指针数组）

什么时候有虚函数表？

一个类中一旦有了虚函数，那么这个类中就有了一个虚函数表，保存这个类中所有虚函数的地址，如果这个类被子类继承了，子类中也会有一张虚函数表

父类的虚函数表和子类的虚函数表一样吗？

<1>如果子类不重写父类的虚函数，那么父类和子类的虚函数表是一样的
<2>如果子类重写了父类的虚函数，那么子类虚函数表中对应的就是子类重写之后的虚函数地址

在这里插入图片描述

  1. 父类有虚函数，那么被子类继承之后，子类中对应的函数也是虚函数！子类中对应函数的virtual关键字可加可不加！
  2. 父类中有函数是虚函数，如果子类有重定义的话，此时被称为重写（覆盖–就是子类中的函数把从父类中继承来的给覆盖了。子类中有且只有一个这样子的函数！！！）！！！！
  3. 重写就必须保证 子类中的函数首部与父类中函数的首部是一模一样的，首部指的是：函数类型 函数名(参数列表)。

动态内存分配中遇到的问题

问题：把new出来的子类对象，赋值给了父对象类型的指针，在整个操作过程中，都是通过父类的指针来操作，使用delete去释放空间的时候，只执行了父类的析构函数，并没有子类的析构函数，可能会造成内存泄漏的问题（在子类的构造函数去new空间了）
在这里插入图片描述

在这里插入图片描述

解决：目标：执行子类的析构函数
将父类的析构函数写成虚函数,子类的析构自然也是虚函数！

在这里插入图片描述

#include <iostream>
using namespace std;
class Shape
{
public:
	Shape(int s = 0, int c = 0) :s(s), c(c)
	{
		cout << "Shape构造" << endl;
	}
	virtual ~Shape()
	{
		cout << "Shape析构" << endl;
	}
	virtual int getC()
	{
		cout << "周长：" << this->c << endl;
		return this->c;
	}
	virtual int getS()
	{
		cout << "面积：" << this->s << endl;
		return this->s;
	}
private:
protected:
	int s;
	int c;
};
class Rect :public Shape
{
public:
	Rect(int a = 0, int b = 0) :a(a), b(b)
	{
		cout << "Rect构造" << endl;
	}
	~Rect()
	{
		cout << "Rect析构" << endl;
	}
	int getC()
	{
		this->c = (this->a + this->b) * 2;
		return this->c;
	}
	int getS()
	{
		this->s = this->a * this->b;
		return this->s;
	}
	void show()
	{
		cout << "周长：" << this->c << ",面积：" << this->s << endl;
	}
private:
protected:
	int a;
	int b;
};
class Circle :public Shape
{
public:
	Circle(int r = 0) :r(r)
	{
		cout << "Circle构造" << endl;
	}
	~Circle()
	{
		cout << "Circle析构" << endl;
	}
	int getC()
	{
		this->c = 2 * 3.14 * this->r;
		return this->c;
	}
	int getS()
	{
		this->s = 3.14 * this->r * this->r;
		return this->s;
	}
	void show()
	{
		cout << "周长：" << this->c << ",面积：" << this->s << endl;
	}
private:
protected:
	int r;
};
void Scs(Shape* demo)
{
	cout << demo->getC() + demo->getS() << endl;
}
int main()
{

	Shape* p = new Circle(4);
	Scs(p);
	delete p;


}

<1>在设计类的时候，为什么建议把析构函数写成虚函数
防止内存泄漏
<2>为什么不执行子类的析构函数就可能会存在内存泄漏的问题
在子类的构造函数去new空间了

重载、重定义、重写的区别

重载：同一个作用域内，函数功能相似，函数名相同、参数不同，与返回值无关的一组函数
重定义：在继承关系中，子类重定义父类的函数，函数名相同即可
重写（覆盖）：在继承关系中，子类重写父类的虚函数
备注：函数首部必须一样
首部：返回值类型 函数名(形式参数列表)

抽象类

在设计类的时候，发现这个类确实需要这样子的一个操作函数，但是在父类中不知道该怎么实现，它的所有的子类都要实现这个函数，并且所有的子类实现这个函数的效果是不一样的，这种情况下，就可以把这个函数写成纯虚函数

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

在这里插入图片描述
注意：抽象类是不能创建对象的
在这里插入图片描述

作用：就是用来被继承的，在子类中去实现这个纯虚函数（每一个子类都要去实现这个纯虚函数）
如果子类没有实现这个纯虚函数，子类也变成了抽象类

#include <iostream>
using namespace std;
class Shape //抽象类
{
public:
	Shape(int s = 0, int c = 0) :s(s), c(c)
	{
		cout << "Shape构造" << endl;
	}
	virtual ~Shape()
	{
		cout << "Shape析构" << endl;
	}
	virtual int getC() = 0;//纯虚函数
	
	virtual int getS() = 0;
	
private:
protected:
	int s;
	int c;
};
class Rect :public Shape
{
public:
	Rect(int a = 0, int b = 0) :a(a), b(b)
	{
		cout << "Rect构造" << endl;
	}
	~Rect()
	{
		cout << "Rect析构" << endl;
	}
	int getC()
	{
		this->c = (this->a + this->b) * 2;
		return this->c;
	}
	int getS()
	{
		this->s = this->a * this->b;
		return this->s;
	}
	void show()
	{
		cout << "周长：" << this->c << ",面积：" << this->s << endl;
	}
private:
protected:
	int a;
	int b;
};
class Circle :public Shape
{
public:
	Circle(int r = 0) :r(r)
	{
		cout << "Circle构造" << endl;
	}
	~Circle()
	{
		cout << "Circle析构" << endl;
	}
	int getC()
	{
		this->c = 2 * 3.14 * this->r;
		return this->c;
	}
	int getS()
	{
		this->s = 3.14 * this->r * this->r;
		return this->s;
	}
	void show()
	{
		cout << "周长：" << this->c << ",面积：" << this->s << endl;
	}
private:
protected:
	int r;
};
void Scs(Shape* demo)
{
	cout << demo->getC() + demo->getS() << endl;
}
int main()
{

	Shape* p = new Circle(4);
	Scs(p);
	delete p;


}

在这里插入图片描述

接口类—抽象类

接口类其实就是抽象类的应用
当抽象类不能实例化对象时，抽象类中的成员变量也就不能初始化，其构造函数也就不能被执行

接口类：类中只有成员函数，没有数据成员，并且成员函数必须是纯虚函数
作用：就是用来被继承的，描述一些能力、协议

#include <iostream>
using namespace std;
//接口类
class fly_land
{
public:
	virtual void fly() = 0;//纯虚函数
	virtual void land() = 0;
};
class Bird :public fly_land
{
public:
	void fly()
	{
		cout << "bird  fly ....." << endl;
	}
	void land()
	{
		cout << "bird land....." << endl;
	}
};
class Plane :public fly_land
{
public:
	void fly()
	{
		cout << "plane fly....." << endl;
	}
	void land()
	{
		cout << "plane land....." << endl;
	}
};
void dosomething(fly_land& demo)
{
	demo.fly();
}
int main()
{
	Bird bird;
	dosomething(bird);

	Plane plane;
	dosomething(plane);
}

在这里插入图片描述

空类对象的内存大小

默认构造函数、析构函数、默认拷贝构造函数、赋值运算符函数、取值运算符函数 const 修饰的取值运算符
空类占内存大小：1字节
在这里插入图片描述
在这里插入图片描述

explicit

作用：修饰构造函数的，对应的构造函数被称为 转换构造函数！！！！
意义：防止构造函数单参数的时候进行自动类型的转换

在这里插入图片描述

final

作用：修饰类和类中的成员函数

修饰类

作用：不能被继承
在这里插入图片描述

修饰成员函数

作用：无法重写
在这里插入图片描述

C++中cout默认输出六位有效数字
weixin_52284980的博客
03-20 1万+
C++中cout默认输出六位有效数字 C++中cout默认输出六位有效数字，以及更改默认保留有效位数的方法（包括保留几位小数） #include<iostream> #include<stdio.h> using namespace std; int main(){ double a = 12.3456789111; double b = 123.456789111; cout<<"默认是六位有效数字,同时还四舍五入:"<<endl; cout&
2023 年 12 月认证 C++ 六级真题解析
10-14
2023 年 12 月认证 C++ 六级真题解析
C++六种for循环
sundynes 之Hello word
03-29 1680
C++ for 循环的6种用法
C++系列六：运算符
聚集机器学习、信息安全
05-09 3594
C++ 中的运算符是程序中非常重要的一部分，可用来对变量、常量和表达式进行各种操作，大大简化代码，提高代码的可读性和执行效率，并且支持面向对象编程。
C++ 六大排序算法实现和比较
406156440的博客
08-20 2661
文章目录一. 快速排序1.1 介绍1.2 函数片段1.3 快排应用二. 归并排序2.1 介绍2.2 函数片段三. 插入排序3.1 介绍3.2 函数片段四. 冒泡排序4.1 介绍4.2 函数片段五. 选择排序5.1 介绍5.2 函数片段六. 桶排序 常用的排序算法 本文介绍多种排序算法, 利用图示进行解析 最后部分是整个可执行带主函数的代码\color{#FF3030}{带主函数的代码}带主函数的代码 一. 快速排序 1.1 介绍 快速排序是一种查找一个值的绝对位置, 根据此位置将序列分成左右两个位置
C++容器概述
weixin_47266712的博客
07-07 2892
C++STL提供了六大组件，彼此之间可以组合套用，这六大组件分别是：容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器STL六大组件的交互关系： 1、容器通过空间配置器取得数据存储空间 2、算法通过迭代器存储空间的内容 3、仿函数可以协助算法完成不同策略的变化 4、适配器可以修饰仿函数容器：就是各种数据结构，如vector、list、deque、set、map等，用于存放数据，从实现的角度来看，STL容器是一种模板类。定义： 在容器内部，元素的摆放是有顺序的。 定义： 关联容器不计较顺序的概念，使用
C++元组(tuple)类型
CairBin的博客
06-12 1万+
元组tuple是C++的一个模板，不同tuple类型的成员类型也不相同，但是一个tuple可以有任意数量的成员。每个tuple类型的成员个数是一定的，但是不同的tuple成员个数可以不同。
C++ Sort函数详解
热门推荐
zhangbw's blog
06-06 13万+
C++sort函数介绍、案例，自定义排序方法。
c++ 六大组件与功能
lfc2017的博客
03-16 1935
STL提供六大组件，彼此可以嵌套使用。 1.容器：各种数据结构，比如vector，list，set，map，deque，用来存放数据。从实作的角度看，STL 容器是一种 class template。就体积而言，这一部份很像冰山在海面下的比率。 2.算法：各种算法如sort,search,copy,erase。从实作的角度看，STL 算法是一种 function template。 3.迭代...
C++ const的用法详解
Mi-ronin的博客
07-13 5万+
const在C/C++中是十分重要的，如果单纯理解为“常量”那么你的格局就小了，今天在这里给大家介绍一下const在C++中具体详细的用法。
C++语言的特点有哪些
qq_46111138的博客
06-07 7262
问：能说一下C++语言的特点有哪些吗？
connect6.rar_c++六子棋_connect6_六子棋_六子棋C++
07-14
《C++实现六子棋游戏开发详解》 六子棋，作为五子棋的变种，因其简单易学、策略多变的特点，逐渐受到棋类爱好者的喜爱。本项目旨在利用C++编程语言，开发一个功能完备、界面友好的六子棋人机对弈和双人对弈的软件，...
ComputerGames.rar_c++六子棋
07-14
【标题】"ComputerGames.rar_c++六子棋" 指的是一个使用C++编程语言开发的六子棋游戏程序，它被压缩在一个名为"ComputerGames.rar"的文件中。六子棋是一种策略型的双人对弈游戏，通常在棋盘上进行，玩家尝试在棋盘上...
liuziqi.rar_c++六子棋_game_六子棋C_六子棋C++_六子棋源
09-23
本篇将围绕"liuziqi.rar"这个压缩包中的"C++六子棋"和"六子棋C"项目，深入探讨其设计原理和实现细节。 首先，我们要了解的是C++和C这两种编程语言在实现六子棋网络对弈平台时各自的特点。C++作为面向对象的语言，其...
2023年9月GESP认证C++六级真题
08-31
23年9月GESP六级真题附答案。推荐六级考生浏览。题目来源于GESP官网。
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 878
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
C 学习（4）
search7的博客
11-05 764
C语言学习，每个模块来自工作中的？？？
常用的c++特性--＞day02
m0_69093426的博客
11-06 508
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
GitLab 提交 C++ 技巧
最新发布
nbspzs的专栏
11-08 180
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
Qt框架下的C++六级单词测试软件课程设计
资源摘要信息:"C++课程设计：六级单词测试软件，基于Qt框架开发.zip" 1. C++课程设计主题解读： 本课程设计以六级单词测试软件为主题，展现了如何将C++编程语言与Qt框架相结合，来创建一个具有实际应用价值的软件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值