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

目录

一、继承

1.继承的基本语法

2.继承方式

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

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

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

6.多继承语法

7.菱形继承

二、多态

1.多态的基本概念

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

3.纯虚函数和抽象类

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

5.虚析构和纯虚析构

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

三、文件操作

1.文本文件

2.二进制文件


一、继承

作用:减少重复代码

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
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值