c++学习心得第二期 多态+文件操作

最新推荐文章于 2022-09-01 15:38:38 发布
最新推荐文章于 2022-09-01 15:38:38 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： C++学习 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37448336/article/details/108941600
版权
本文详细探讨了C++中的多态性，包括静态多态与动态多态的概念，以及如何通过虚函数、纯虚函数和抽象类实现多态。同时，通过计算器、饮品制作和电脑组装等案例展示了多态的实际应用。此外，还介绍了文件操作，包括文本文件和二进制文件的读写操作，强调了虚析构函数在多态内存管理中的作用。
摘要由CSDN通过智能技术生成

c++学习心得第二期 多态+文件操作

一、多态

1、多态的基本概念

多态是C++面向对象三大特性之一
多态分为两类
静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名
动态多态: 派生类和虚函数实现运行时多态
静态多态和动态多态区别：
静态多态的函数地址早绑定 - 编译阶段确定函数地址
动态多态的函数地址晚绑定 - 运行阶段确定函数地址

#include<iostream>
#include<string>
using namespace std;
//因为早绑定，所以地址已经是animal的地址了  想执行小猫说话但结果是动物说话
class Animal{

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

};
//执行说话函数
//地址早绑定 在编译阶段确定函数的地址。
void doSpeak(Animal &animal)
{
	animal.speak();
}
void test01()
{
	Cat cat;
	doSpeak(cat);

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

在这里插入图片描述

#include<iostream>
#include<string>
using namespace std;
class Animal{
//在函数前加 virtual 变成动态绑定。
public:
	virtual void   speak()
	{
		cout <<"动物在说话" << endl;
	}
};
class Cat :public Animal{
public:
	void speak()
	{
		cout <<"小猫在说话" << endl;
	}

};
void doSpeak(Animal &animal)
{
	animal.speak();
}
void test01()
{
	Cat cat;
	doSpeak(cat);

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

在这里插入图片描述

多态满足条件
有继承关系
子类重写父类中的虚函数
多态使用条件
父类指针或引用指向子类对象
重写：函数返回值类型 函数名 参数列表 完全一致称为重写
在这里插入图片描述

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

分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类
多态的优点：
代码组织结构清晰
可读性强
利于前期和后期的扩展以及维护

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

class AbstractCalculator{
	
public :
	virtual int result() = 0;
public:
	int num1;
	int num2;
};
class AddCalculator:public AbstractCalculator{

public:
	AddCalculator(int num1,int num2)
	{
		this->num1 = num1;
		this->num2 = num2;
	}
	int result()
	{
		return num1 + num2;
	}
};
class SubstractorCalculator :public AbstractCalculator{

public:
	SubstractorCalculator(int num1, int num2)
	{
		this->num1 = num1;
		this->num2 = num2;
	}
	int result()
	{
		return num1 - num2;
	}
};
class MultiplyrCalculator :public AbstractCalculator{

public:
	MultiplyrCalculator(int num1, int num2)
	{
		this->num1 = num1;
		this->num2 = num2;
	}
	int result()
	{
		return num1*num2;
	}
};
void test01()
{
	AbstractCalculator *abc = new AddCalculator(10, 10);
	cout << abc->result() << endl;
	delete abc;

	abc = new SubstractorCalculator(20,10);
	cout << abc->result() << endl;
	delete abc;

	abc = new MultiplyrCalculator(20, 10);
	cout << abc->result() << endl;
	delete abc;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

3、纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;
当类中有了纯虚函数，这个类也称为抽象类
抽象类特点：
无法实例化对象
子类必须重写抽象类中的纯虚函数，否则也属于抽象类

#include<iostream>
#include<string>
using namespace std;
//纯虚函数
//类中只要有一个纯虚函数就称为抽象类
//抽象类无法实例化对象
//子类必须重写父类中的纯虚函数，否则也属于抽象类
class Base{
public:
	virtual void func() = 0;
};
class Son :public Base{
public:
	void func()
	{
		cout <<"调用了 func函数" << endl;
	}

};
void test01()
{
	Base *base;
	//设置了纯虚函数即为抽象函数，因此抽象函数不能实例化
	//base = new Base;
	base = new Son();
	base->func();
	delete base;//分配到堆区的内存要删除
}
int main()
{
	test01();
	system("pause");
	return 0;
}

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

制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料
利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

#include<iostream>
#include<string>
using namespace std;
class AbstractDrinking
{
public:
	virtual void Boil() = 0;
	virtual void Brew() = 0;
	virtual void PourInCup() = 0;
	virtual void PusSomething() = 0;

	void MakeDrink()
	{
		Boil();
		Brew();
		PourInCup();
		PusSomething();
	}
};

class Coffee :public AbstractDrinking
{
	void Boil()
	{
		cout <<"矿泉水" << endl;
	}
	void Brew()
	{
		cout <<"泡" << endl;
	}
	void PourInCup()
	{
		cout <<"倒" << endl;
	}
	void PusSomething()
	{
		cout <<"加牛奶" << endl;
	}


};
class Tea :public AbstractDrinking
{
	void Boil()
	{
		cout << "自来水" << endl;
	}
	void Brew()
	{
		cout << "加热" << endl;
	}
	void PourInCup()
	{
		cout << "泼" << endl;
	}
	void PusSomething()
	{
		cout << "加树叶" << endl;
	}
};
//使用引用调用虚函数和多态
void DoWork(AbstractDrinking& drinking)
{
	drinking.MakeDrink();
}
//使用指针调用虚函数和多态
void DoWorkByPoint(AbstractDrinking *dringing)
{
	dringing->MakeDrink();
}
void test01()
{
	//使用引用调用虚函数和多态
	Tea tea;
	DoWork(tea);
	Coffee coffee;
	DoWork(coffee);
	cout <<"------------------>" << endl;
	//使用指针调用虚函数和多态
	AbstractDrinking *drinking = new Tea;
	DoWorkByPoint(drinking);
	delete drinking;
	drinking = new Coffee;
	DoWorkByPoint(drinking);
	delete drinking;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

5、虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方式：将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性：
可以解决父类指针释放子类对象
都需要有具体的函数实现
虚析构和纯虚析构区别：
如果是纯虚析构，该类属于抽象类，无法实例化对象
虚析构语法：
virtual ~类名(){}
纯虚析构语法：
virtual ~类名() = 0;
类名::~类名(){}

总结：

  1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
  2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
  3. 拥有纯虚析构函数的类也属于抽象类
#include<iostream>
#include<string>
using namespace std;

class Animal{
public:
	Animal()
	{
		cout <<"Animal 构造函数的调用" << endl;
	}
	~Animal()
	{
		cout <<"Animal 析构函数的调用" << endl;
	}
	virtual void speak() = 0;

};

class Cat :public Animal
{
public:
	Cat()
	{
		cout <<"小猫的构造函数在调用" << endl;
	}
	~Cat()
	{
		cout <<"小猫的析构函数在调用" << endl;
	}
	void speak()
	{
		cout <<"小猫在叫" << endl;
	}
};

void test01()
{
	Animal* animal = new Cat;
	animal->speak();
	delete animal;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

在这里插入图片描述

小猫的析构函数没有调用，如果小猫中存在堆区的分配，有开辟的内存空间没有释放会造成内存泄漏。因此要在父类中使用虚析构和纯虚析构，可以是子类中的析构函数被调用。

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

class Animal{
public:
	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 <<"小猫的构造函数在调用" << endl;
		m_Name = new string(name);
	}
	~Cat()
	{
		if (m_Name != NULL)
		{
			delete m_Name;
			m_Name = NULL;
		}
		cout <<"小猫的析构函数在调用" << endl;
	}
	void speak()
	{
		cout <<*m_Name<<"小猫在叫" << endl;
	}
	string *m_Name;
};

void test01()
{
	Animal* animal = new Cat("Jack");
	animal->speak();
	delete animal;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

在这里插入图片描述

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

电脑主要组成部件为 CPU（用于计算），显卡（用于显示），内存条（用于存储）
将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试时组装三台不同的电脑进行工作

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

//创建 cpu memory videocard 虚函数  创建Inter和Lenovo对虚函数进行实现。 
//创建 computer 作为cpu memory 和 videocard的集合类  进行组装
class Cpu{
public:
	virtual void calculate() = 0;
};
class VideoCard
{
public:
	virtual void display() = 0;
};
class Memory
{
public:
	virtual void storage() = 0;
};
class Computer
{
public:
	Computer(Cpu* c,Memory *m,VideoCard *v)
	{
		cpu = c;
		memory = m;
		videocard = v;
	}
	~Computer()
	{
		if (cpu != NULL)
		{
			delete cpu;
			cpu = NULL;
		}
		if (memory != NULL)
		{
			delete cpu;
			memory = NULL;
		}
		if (videocard != NULL)
		{
			delete cpu;
			videocard = NULL;
		}
	}
	void work()
	{
		cpu->calculate();
		memory->storage();
		videocard->display();
	}
private:
	Cpu *cpu;
	Memory *memory;
	VideoCard *videocard;
};

//具体厂商
//Intel厂商
class IntelCPU :public Cpu
{
public:
	virtual void calculate()
	{
		cout << "Intel的CPU开始计算了！" << endl;
	}
};

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

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

//Lenovo厂商
class LenovoCPU :public Cpu
{
public:
	virtual void calculate()
	{
		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 * intelCpu = new IntelCPU;
	VideoCard * intelCard = new IntelVideoCard;
	Memory * intelMem = new IntelMemory;

	cout << "第一台电脑开始工作：" << endl;
	//创建第一台电脑
	Computer * computer1 = new Computer(intelCpu, intelMem, intelCard);
	computer1->work();
	delete computer1;

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

	cout << "-----------------------" << endl;
	cout << "第三台电脑开始工作：" << endl;
	//第三台电脑组装
	Computer * computer3 = new Computer(new LenovoCPU, new LenovoMemory, new LenovoVideoCard);
	computer3->work();
	delete computer3;

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

二、文件操作

程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放
通过文件可以将数据持久化
C++中对文件操作需要包含头文件 < fstream >
文件类型分为两种：
文本文件 - 文件以文本的ASCII码形式存储在计算机中
二进制文件 - 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们
操作文件的三大类:
ofstream：写操作
ifstream： 读操作
fstream ： 读写操作

1.文本写文件

写文件步骤如下：
包含头文件
#include
创建流对象
ofstream ofs;
打开文件
ofs.open(“文件路径”,打开方式);
写数据
ofs << “写入的数据”;
关闭文件
ofs.close();

​在这里插入图片描述

注意： 文件打开方式可以配合使用，利用|操作符
**例如：**用二进制方式写文件 ios::binary | ios:: out

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

void test01()
{
	ofstream ofs;
	ofs.open("text.txt",ios::out);
	ofs << "姓名：张三" << endl;
	ofs << "性别：男" << endl;
	ofs.close();
}

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

在这里插入图片描述在这里插入图片描述

文件操作必须包含头文件 fstream
读文件可以利用 ofstream ，或者fstream类
打开文件时候需要指定操作文件的路径，以及打开方式
利用<<可以向文件中写数据
操作完毕，要关闭文件

2.文本读文件

读文件与写文件步骤相似，但是读取方式相对于比较多
读文件步骤如下：
包含头文件
#include
创建流对象
ifstream ifs;
打开文件并判断文件是否打开成功
ifs.open(“文件路径”,打开方式);
读数据
四种方式读取
关闭文件
ifs.close();

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

void test01()
{
	ifstream ifs;
	ifs.open("text.txt",ios::in);
	if (!ifs.is_open())
	{
		cout <<"文件打开失败" << endl;
		return;
	}

	string buf;
	while (getline(ifs,buf))
	{
		cout <<buf << endl;

	}

}

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

3、二进制文件

以二进制的方式对文件进行读写操作
打开方式要指定为 ios::binary

4、二进制写文件

二进制方式写文件主要利用流对象调用成员函数write
函数原型 ：ostream& write(const char * buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数

文件输出流对象 可以通过write函数，以二进制方式写数据

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

class Person{
public:
	char m_Name[64];
	int m_Age;
};
//二进制写文件
void test01()
{
	//创建输出流对象
	ofstream ofs("person.txt",ios::out|ios::binary);
	Person p = {"张三",18};
	ofs.write((const char*)&p,sizeof(p));
	ofs.close();
}

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

5、二进制读文件

二进制方式读文件主要利用流对象调用成员函数read
函数原型：istream& read(char *buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数

文件输入流对象 可以通过read函数，以二进制方式读数据

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

class Person{
public:
	char m_Name[64];
	int m_Age;
};
//二进制写文件
void test01()
{
	ifstream ifs("person.txt",ios::in|ios::binary);
	if (!ifs.is_open())
	{
		cout <<"文件打开失败" << endl;
	}
	Person p;
	ifs.read((char*)&p,sizeof(p));
	cout <<"姓名  " <<p.m_Name <<"  年龄  " <<p.m_Age<< endl;
}

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

在这里插入图片描述

素位明哲
关注
专栏目录
C++ 多态
TPON的博客
10-29 1545
C++ 多态，虚函数表，虚函数表指针，重写（覆盖）
多态（C++）
缥缈烟雨
07-09 2109
1.多态的概念   同一种东西在不同场景下的多种形态    比如举个例子：见人说人话，见鬼说鬼话2.动态多态的分类       1&gt;静态多态  静态多态是编译器在编译期间完成的，编译器根据函数实参的类型(可能会进行隐式类型的转换)，可推断出要调用哪个函数，如果有对应的函数就调用该函数，否则出现编译错误  2&gt;动态多态    我们先来看一段代码：#define _CRT_SECURE_N...
《C++》13 C++ 多态
HerGhost
03-30 543
C++ 多态多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。下面的实例中，基类 Shape 被派生为两个类，如下所示：#include <iostream> using namespace std;class Shape { protected: int w
C++——多态
Tianzez的博客
04-23 1816
C++知识总结目录索引 1. 何为多态 　　多态一词最初来源于希腊语，意思是具有多种形式或形态的情形，在C++中是指同样的消息被不同类型的对象接收时导致不同的行为，这里讲的消息就是指对象的成员函数的调用，而不同的行为是指不同的实现，也就是调用了不同的函数。简而言之就是“一种接口，多种实现（方法）”。 　　 2. 多态的分类 多态可分为静态多态和动态多态，具体的分类情况如下：...
C++的多态
Lavender的博客
09-06 182
1. C++的多态性： 在基类的函数前加上virtual关键字,在派生类中重写该函数，运行时将会根据对象的时间类型来调用相应的函数。如果对象类型时派生类，就调用派生类的函数；如果对象类型时基类，就调用基类的函数。 1）用virtual 关键字声明的函数叫做虚函数，虚函数肯定是类的成员函数； 2）存在虚函数的类都有一个一维的虚函数表叫做虚表，类的对象有一个指向虚表的开始指针。虚表是和类对应的，虚表指针是和对象对应的； 3）多态性是一个接口多种实现，是面向对象的核心，分为类的多态性和函数的多态性；
c++学习心得，初学者必备
01-13
### C++ 学习心得与初学者指南 #### 前言 在计算机科学领域，C++ 是一门非常重要的编程语言。它不仅被广泛应用于系统软件、游戏开发、高性能计算等多个方面，也是许多大型企业（如微软、谷歌等）的核心技术之一。...
C++程序员学习心得：从基础到VC++
5. **学习VC++**：《Inside Visual C++》是学习VC++的优秀教材，尤其是清华大学出版社的中译本《Visual C++技术内幕（第四版）》。这本书详细介绍了如何使用Visual Studio开发C++应用，是初学者和进阶者的宝贵资源。...
C++学习心得（3）多态性与虚函数
会思考的浣熊的专栏
10-14 1696
C++学习心得（3）多态性与虚函数 ——from 谭浩强.C++面向对象程序设计(第一版) 2014/10/13 6.1    多态性的概念     在C++中，多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数。     面向对象的描述：向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为。即每个对象可以用自己的方式去响应共同的消息。
学习心得--C++学习经典
03-05
从给定的文件信息中，我们可以提炼出一系列与C++学习相关的知识点，这些知识点涵盖了学习方法、资源推荐、编程实践以及个人发展等多个方面。以下是对这些知识点的详细解读： 1. **C++作为一门基础语言的重要性**：...
C++学习心得
weixin_56838059的博客
09-01 1983
C++学习心得 一周的C++学习结束了 从C++的简介，各种专业术语的介绍到最后的标准模板库，对于这个c的加强版的语言有了一定的认识理解，但是由于6天时间学完了全部，而且由于疫情在家里上了两天网课，对于一些运用层次还不是很熟悉，学的重点放在了面向对象。对于学到的内容，对重点进行了以下整理，太过简单的或者不重要的仅作了解，不做概述。 C++里的特性及专业术语 （1）类：class 描写现实世界中的事物（包括特征和行为），例如：人，特征：身高、年龄、性别、肤色，行为：吃饭、走路、睡觉等等，它实质是抽象的描述事物
c++ 多态
Z_JUAN1的博客
08-26 326
1.概念：               一个东西可以在不同场景下变现出多种状态。             例如：*  /   &amp;    *：在两个操作数之间为乘，在指针变量前面为解引用    &amp;：在变量前为取地址，在变量后为引用，在两个操作数之间为与运算符 2.  分类 （1） 静态多态（静态链编/静态绑定/前期绑定）：程序编译期可以确定程序的行为           例...
c++ 多态
weixin_60413769的博客
03-05 429
这里是Joe自己的学习笔记，如果能帮助你，那我受宠若惊！ 什么是多态？ 简单来说就是 同样的消息被不同的类型的对象接收时导致的不同的行为。 多态分类： 重载多态 强制多态 包含多态 参数多态 1.多态的实现 编译时：在编译的过程中确定同名操作的具体操作对象 运行时：在程序运行时动态的确定操作所针对的对象。，这种确定操作的具体对象就是绑定 绑定：标识符和储存地址的相联系。 静态绑定：在编译连接阶段完成的情况。根据类型匹配等特征确定程序中操作调用与执行该代码的关系 动态绑定：程序运行之后
c++多态
m0_60773087的博客
04-19 1138
c++多态
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值