C++继承、多态、文件操作(黑马程序员教程笔记)

最新推荐文章于 2022-08-07 11:45:33 发布

暗里花儿

最新推荐文章于 2022-08-07 11:45:33 发布

阅读量559

点赞数

分类专栏： C++ 文章标签： c++

本文链接：https://blog.csdn.net/anlihuaer/article/details/120811269

版权

C++ 专栏收录该内容

5 篇文章 3 订阅

订阅专栏

一、继承

作用：减少重复代码

1.继承的基本语法

class 子类：继承方式父类

子类也称为派生类：包含两大部分：一类是从基类继承过来的，一类是自己增加的成员

父类也成为基类

2.继承方式

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

3.继承中构造和析构顺序

先构造父类，再构造子类，析构的顺序相反。

4.继承同名成员处理方式

当子类与父类出现同名的成员，访问子类同名成员：直接访问、访问父类同名成员：需加作用域。

#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		m_a = 100;
	}
	void func()
	{
		cout << "Base下func"  << endl;
	}
	void func(int a)
	{
		cout << "Base下func(int a)" << endl;
	}
	int m_a;
};
class Son :public Base
{
public:
	Son()
	{
		m_a = 200;
	}
	void func()
	{
		cout << "Son下func"  << endl;
	}
	int m_a;
};
void test1()//同名成员属性
{
	Son s;
	cout <<"Son 下 m_A=" << s.m_a <<endl;
	cout <<"Base下 m_A=" << s.Base::m_a << endl;
}
void test2()//同名成员函数
{
	Son s;
	s.func();
	s.Base::func();//注：如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
	               //如果想访问父类中被隐藏的同名成员函数，需加作用域
	s.Base::func(100);
}
int main()
{
	test1();
	test2();
	system("pause");
	return 0;
}

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

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

void test()
{
	//通过对象访问
	Son s;
	cout << "Son下m_a=" << s.m_a << endl;
	cout << "Base下m_a=" << s.Base::m_a << endl;
	//通过类名访问
	cout << "Son下m_a=" << Son::m_a << endl;
	cout << "Son下m_a=" << Son::Base::m_a << endl;
	//第一个：代表通过类名访问、第二个：代表访问父类作用域下
}

6.多继承语法

c++允许一个类继承多个类

语法：class 子类：继承方式父类1，继承方式父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

7.菱形继承

两个派生类继承同一个基类

又有某个类同时继承这两个派生类

二、多态

1.多态的基本概念

（1）多态分为两类

静态多态：函数重载和运算符重载属于静态多态，复用函数名：函数地址早绑定(运行阶段确定函数地址)

动态多态：派生类和虚函数实现运行时多态：函数地址晚绑定（运行阶段确定函数地址）

（2）多态满足条件：有继承关系、子类重写父类中的虚函数

（3）多态使用：父类指针或引用指向子类对象

2.多态案例——计算器类

实现两个操作数进行计算的计算器类

#include<iostream>
using namespace std;
//实现计算器抽象类
class Calculator
{
public:
	virtual int getResult()
	{
		return 0;
	}
	int m_Num1;
	int m_Num2;
};
//加法计算器类
class AddCalculator:public Calculator
{
public:
	int getResult()
	{
		return m_Num1+m_Num2;
	}
};
//减法计算器类
class SubCalculator :public Calculator
{
public:
	int getResult()
	{
		return m_Num1 - m_Num2;
	}
};
//乘法计算器类
class MulCalculator :public Calculator
{
public:
	int getResult()
	{
		return m_Num1 * m_Num2;
	}
};
void test1()
{
	//父类指针或引用指向子类对象
	Calculator *c=new AddCalculator;
	c->m_Num1 = 10;
	c->m_Num2 = 10;
	cout << c->m_Num1 << "+" << c->m_Num2 << "=" << c->getResult() << endl;
	//堆区数据用完后记得销毁
	delete c;
}
int main()
{
	test1();
	system("pause");
	return 0;
}

3.纯虚函数和抽象类

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

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

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

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

#include<iostream>
using namespace std;
class Base
{
public:
	virtual void func() = 0;
};
class Son :public Base
{
public:
	void func() {};//子类必须重写父类中的纯虚函数，否则也无法实例化对象
};
void test1()
{
	//父类指针或引用指向子类对象
	Base *base=new Son;
	base->func();
}
int main()
{
	test1();
	system("pause");
	return 0;
}

4.多态案例——制作饮品

案例描述：制作饮品的大致流程为：煮水、冲泡、倒入杯中、加入辅料；提供抽象制作饮品基类，提供子类制作咖啡和茶叶。

#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 Coffee
{
	abs->makeDrink();
	delete abs;
}
void test1()
{
	doWork(new Coffee);
}
int main()
{
	test1();
	system("pause");
	return 0;
}

5.虚析构和纯虚析构

（1）多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

（2）解决方式：将父类中的析构函数改为虚析构或者纯虚析构

（3）虚析构和纯虚析构共性：可以解决父类指针释放子类对象、都需要具体的函数实现

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

（4）虚析构语法：virtual ~类名（）{}

纯虚析构语法：：virtual ~类名（）=0；

类名：：~类名（）{}

#include<iostream>
using namespace std;
#include<string>
class Animal
{
public:
	Animal()
	{
		cout << "Animal构造函数调用" << endl;
	}
	virtual ~Animal()//虚析构：可以解决父类指针释放子类对象时不干净的问题
	{
		cout << "Animal析构函数调用" << endl;
	}
	virtual void speak() = 0;
};
class Cat :public Animal
{
public:
	Cat(string name)
	{
		m_name =new string(name);
		cout << "Cat构造函数调用" << endl;
	}
	void speak()
	{
		cout <<*m_name << "小猫在说话" << endl;
	}
	~Cat()
	{
		if (m_name != NULL)
		{
			cout << "Cat析构函数调用" << endl;
			delete m_name;
			m_name = NULL;
		}
	}
	string* m_name;
};
void test1()
{
	Animal* animal = new Cat("Tom");//父类指针指向子类对象
	animal->speak();
	delete animal;
}
int main()
{
	test1();
	system("pause");
	return 0;
}

6.多态案例——电脑组装

电脑主要组成部件为CPU、显卡、内存条

将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件

创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口

测试时组装三台不同的电脑进行工作

#include<iostream>
using namespace std;
#include<string>
class CPU
{
public:
	virtual void calculate() = 0;
};
class VideoCard
{
public:
	virtual void diaplay() = 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->calculate();
		m_vc->diaplay();
		m_mem->storage();
	}
	//提供析构函数释放3个电脑零件
	~Computer()
	{
		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;
	VideoCard* m_vc;
	Memory* m_mem;
};
//具体零件厂商
class IntelCpu :public CPU
{
	void calculate()
	{
		cout << "Intel的CPU开始计算了" << endl;
	}
};
class IntelVideoCard :public VideoCard
{
	void diaplay()
	{
		cout << "Intel的显卡开始了" << endl;
	}
};
class IntelMemory :public Memory
{
	void storage()
	{
		cout << "Intel的内存条开始了" << endl;
	}
};

class LenovoCpu :public CPU
{
	void calculate()
	{
		cout << "Intel的CPU开始计算了" << endl;
	}
};
class LenovoVideoCard :public VideoCard
{
	void diaplay()
	{
		cout << "Intel的显卡开始了" << endl;
	}
};
class LenovoMemory :public Memory
{
	void storage()
	{
		cout << "Intel的内存条开始了" << endl;
	}
};

void test01()
{
	//第一台电脑零件
	CPU* intelCpu = new IntelCpu;
	VideoCard* intelcard = new IntelVideoCard;
	Memory* intelmem = new IntelMemory;
	//创建第一台电脑
	Computer* computer1 = new Computer(intelCpu, intelcard, intelmem);
	computer1->Work();
	delete computer1;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

三、文件操作

（1）程序运行时产生的数据都属于临时数据，程序一旦结束都会被释放，通过文件可以将数据持久化。

（2）c++中对文件操作需要包含头文件<fstream>

（3）文件类型分为两种：文本文件（ASCII码形式存储）、二进制文件（二进制形式存储）

（4）操作文件的三大类：ofstream(写操作）ifstream(读操作) fstream(读写操作)

1.文本文件

（1）写文件

写文件步骤如下：

a.包含头文件 #include<fstream>

b.创建流对象 ofstream ofs;

c.打开文件 ofs.open("文件路径",打开方式);

d.写数据 ofs<<"写入的数据";

e.关闭文件 ofs.close();

文件打开方式

（2）读文件

读文件步骤如下：

a.包含头文件 #include<fstream>

b.创建流对象 ifstream ifs;

c.打开文件并判断文件是否打开成功 ifs.open("文件路径"，打开方式)

d.读数据四种方式读取

e.关闭文件 ifs.close();

2.二进制文件

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

教程地址：黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili

暗里花儿

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
C++继承、多态、文件操作(黑马程序员教程笔记)

目录一、继承1.继承的基本语法2.继承方式3.继承中的对象模型4.继承中构造和析构顺序5.继承同名成员处理方式6.继承同名静态成员处理方式7.多继承语法8.菱形继承二、多态1.多态的基本概念2.多态案例——计算器类3.纯虚函数和抽象类4.多态案例——制作饮品5.虚析构和纯虚析构6.多态案例——电脑组装三、文件操作1.文本文件2.二进制文件一、继承作用：减少重复代码1.继承的基本语法class 子类：继承方式父类
复制链接

扫一扫