c++核心编程继承和多态 、文件简单读写

最新推荐文章于 2022-03-14 20:24:29 发布
最新推荐文章于 2022-03-14 20:24:29 发布
阅读量210 收藏 1
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/J_bz_Redio/article/details/112310693
版权

4.6 继承

继承是面向对象三大特性之一

有些类与类之间存在特殊的关系，例如下图中：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ePVg2IyK-1610002143050)(assets/1544861202252.png)]

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

这个时候我们就可以考虑利用继承的技术，减少重复代码

4.6.1 继承的基本语法

例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同

接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处

普通实现：

//Java页面
class Java 
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "JAVA学科视频" << endl;
	}
};
//Python页面
class Python
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};
//C++页面
class CPP 
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "C++学科视频" << endl;
	}
};

void test01()
{
	//Java页面
	cout << "Java下载视频页面如下： " << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "--------------------" << endl;

	//Python页面
	cout << "Python下载视频页面如下： " << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "--------------------" << endl;

	//C++页面
	cout << "C++下载视频页面如下： " << endl;
	CPP cp;
	cp.header();
	cp.footer();
	cp.left();
	cp.content();

}

int main() {

	test01();

	system("pause");

	return 0;
}

继承实现：

//公共页面
class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}

	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分类列表)" << endl;
	}

};

//Java页面
class Java : public BasePage
{
public:
	void content()
	{
		cout << "JAVA学科视频" << endl;
	}
};
//Python页面
class Python : public BasePage
{
public:
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};
//C++页面
class CPP : public BasePage
{
public:
	void content()
	{
		cout << "C++学科视频" << endl;
	}
};

void test01()
{
	//Java页面
	cout << "Java下载视频页面如下： " << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "--------------------" << endl;

	//Python页面
	cout << "Python下载视频页面如下： " << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "--------------------" << endl;

	//C++页面
	cout << "C++下载视频页面如下： " << endl;
	CPP cp;
	cp.header();
	cp.footer();
	cp.left();
	cp.content();


}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

继承的好处：可以减少重复的代码

class A : public B;

A 类称为子类 或 派生类

B 类称为父类 或 基类

派生类中的成员，包含两大部分：

一类是从基类继承过来的，一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性。

4.6.2 继承方式

继承的语法：class 子类 : 继承方式 父类

继承方式一共有三种：

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y8QqK2tK-1610002198463)(assets/clip_image002.png)]

示例：

class Base1
{
public: 
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//公共继承
class Son1 :public Base1
{
public:
	void func()
	{
		m_A; //可访问 public权限
		m_B; //可访问 protected权限
		//m_C; //不可访问
	}
};

void myClass()
{
	Son1 s1;
	s1.m_A; //其他类只能访问到公共权限
}

//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2:protected Base2
{
public:
	void func()
	{
		m_A; //可访问 protected权限
		m_B; //可访问 protected权限
		//m_C; //不可访问
	}
};
void myClass2()
{
	Son2 s;
	//s.m_A; //不可访问
}

//私有继承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3:private Base3
{
public:
	void func()
	{
		m_A; //可访问 private权限
		m_B; //可访问 private权限
		//m_C; //不可访问
	}
};
class GrandSon3 :public Son3
{
public:
	void func()
	{
		//Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
		//m_A;
		//m_B;
		//m_C;
	}
};
4.6.3 继承中的对象模型

**问题：**从父类继承过来的成员，哪些属于子类对象中？

示例：

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C; //私有成员只是被隐藏了，但是还是会继承下去
};

//公共继承
class Son :public Base
{
public:
	int m_D;
};

void test01()
{
	cout << "sizeof Son = " << sizeof(Son) << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

利用工具查看：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-94tSSrIV-1610002198466)(assets/1545881904150.png)]

打开工具窗口后，定位到当前CPP文件的盘符

然后输入： cl /d1 reportSingleClassLayout查看的类名 所属文件名

效果如下图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-isVgCjB2-1610002198480)(assets/1545882158050.png)]

结论： 父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

4.6.4 继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造和析构顺序是谁先谁后？

示例：

class Base 
{
public:
	Base()
	{
		cout << "Base构造函数!" << endl;
	}
	~Base()
	{
		cout << "Base析构函数!" << endl;
	}
};

class Son : public Base
{
public:
	Son()
	{
		cout << "Son构造函数!" << endl;
	}
	~Son()
	{
		cout << "Son析构函数!" << endl;
	}

};


void test01()
{
	//继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
	Son s;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

4.6.5 继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域

示例：

class Base {
public:
	Base()
	{
		m_A = 100;
	}

	void func()
	{
		cout << "Base - func()调用" << endl;
	}

	void func(int a)
	{
		cout << "Base - func(int a)调用" << endl;
	}

public:
	int m_A;
};


class Son : public Base {
public:
	Son()
	{
		m_A = 200;
	}

	//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
	//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
	void func()
	{
		cout << "Son - func()调用" << endl;
	}
public:
	int m_A;
};

void test01()
{
	Son s;

	cout << "Son下的m_A = " << s.m_A << endl;
	cout << "Base下的m_A = " << s.Base::m_A << endl;

	s.func();
	s.Base::func();
	s.Base::func(10);

}
int main() {

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

总结：

  1. 子类对象可以直接访问到子类中同名成员
  2. 子类对象加作用域可以访问到父类同名成员
  3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数
4.6.6 继承同名静态成员处理方式

问题：继承中同名的静态成员在子类对象上如何进行访问？

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

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域

示例：

class Base {
public:
	static void func()
	{
		cout << "Base - static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base - static void func(int a)" << endl;
	}

	static int m_A;
};

int Base::m_A = 100;

class Son : public Base {
public:
	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
	static int m_A;
};

int Son::m_A = 200;

//同名成员属性
void test01()
{
	//通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;

	//通过类名访问
	cout << "通过类名访问： " << endl;
	cout << "Son  下 m_A = " << Son::m_A << endl;
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

//同名成员函数
void test02()
{
	//通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	s.func();
	s.Base::func();

	cout << "通过类名访问： " << endl;
	Son::func();
	Son::Base::func();
	//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
	Son::Base::func(100);
}
int main() {

	//test01();
	test02();

	system("pause");

	return 0;
}

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）

4.6.7 多继承语法

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

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

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

C++实际开发中不建议用多继承

示例：

class Base1 {
public:
	Base1()
	{
		m_A = 100;
	}
public:
	int m_A;
};

class Base2 {
public:
	Base2()
	{
		m_A = 200;  //开始是m_B 不会出问题，但是改为mA就会出现不明确
	}
public:
	int m_A;
};

//语法：class 子类：继承方式 父类1 ，继承方式 父类2 
class Son : public Base2, public Base1 
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
public:
	int m_C;
	int m_D;
};


//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结： 多继承中如果父类中出现了同名情况，子类使用时候要加作用域

4.6.8 菱形继承

菱形继承概念：

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

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

​ 这种继承被称为菱形继承，或者钻石继承

典型的菱形继承案例：

菱形继承问题：
在这里插入图片描述

  1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。

  2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

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

//#### 4.6.8 菱形继承

//** 菱形继承概念：**
//
//​	两个派生类继承同一个基类
//​	又有某个类同时继承者两个派生类
//​	这种继承被称为菱形继承，或者钻石继承
//
//** 菱形继承问题：**
//
//1.羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。
//
//2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

//动物类
class Animal
{
public:
	int age;
};

//羊类
class sheep :virtual public Animal
{
public:
	//int age;
};

//驼类
class tuo :virtual public Animal
{
public:
	//int age;
};

class sheeptuo : public sheep,  public tuo
{

};
void test50()
{
	sheeptuo p;

	p.sheep::age = 18;
	p.tuo::age = 28;
	//当出现菱形继承时候，有两个父类拥有相同数据，需要加以作用域区分
	cout << "p.sheep::age=" << p.sheep::age << endl;
	cout << "p.sheep::age=" << p.tuo::age << endl;

	//这份数据数据我们知道只要有一份就可以，菱形继承导致数据有两份，导致资源浪费
	//利用虚继承可以解决菱形继承问题
	//继承之前，加上关键字virtual 变为虚继承
	//Animal 类称为 虚基类
	cout << "p.age=" << p.age << endl;//虚继承后就只有一份数据

}

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

总结：

  • 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
  • 利用虚继承可以解决菱形继承问

4.7 多态

4.7.1 多态的基本概念

多态是C++面向对象三大特性之一

多态分为两类

  • 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名
  • 动态多态: 派生类和虚函数实现运行时多态

静态多态和动态多态区别：

  • 静态多态的函数地址早绑定 - 编译阶段确定函数地址
  • 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

下面通过案例进行讲解多态

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


//### 4.7  多态
//
//#### 4.7.1 多态的基本概念
//** 多态是C++面向对象三大特性之一**
//多态分为两类
//
//* 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名
//* 动态多态 : 派生类和虚函数实现运行时多态
//
//静态多态和动态多态区别：
//
//* 静态多态的函数地址早绑定 - 编译阶段确定函数地址
//* 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
//下面通过案例进行讲解多态

//多态
//动物
class Animal1
{
public:
	//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
	virtual void speak()//虚函数
	{
		cout << "动物在说话" << endl;
	}
};



//猫类
class cat :public Animal1
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};
//狗类
class dog :public Animal1
{
public:
	void speak()
	{
		cout << "小狗在说话" << endl;
	}
};

//执行说话的函数

//地址早绑定   在编译阶段确定了函数地址

//如果想要猫说话  那么这个地址就不能提前绑定   ，需要在运行阶段绑定，地址晚绑定
//我们希望传入什么对象，那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定，那么静态联编
//如果函数地址在运行阶段才能确定，就是动态联编

//动态多态 满足条件
//1.得有继承关系
//2.子类要重写父类虚函数     重写（函数返回值、函数名称、 参数列表完全相同）


//动态多态使用
//父类的指针或引用指向子类对象
void dospeak(Animal1 &animal)  //Animal1 的引用 = cat；
{
	animal.speak();
}

void test51()
{
	cat cat1;

	dospeak(cat1);

	dog dog1;
	dospeak(dog1);
}
 
int main()
{
	test51();
	system("pause");
	return 0;
}

总结：

多态满足条件

  • 有继承关系
  • 子类重写父类中的虚函数

多态使用条件

  • 父类指针或引用指向子类对象

重写：函数返回值类型 函数名 参数列表 完全一致称为重写

多态原理

在这里插入图片描述

4.7.2 多态案例一-计算器类

案例描述：

分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

多态的优点：

  • 代码组织结构清晰
  • 可读性强
  • 利于前期和后期的扩展以及维护
#include<iostream>
#include<string>
using namespace std;

//案例描述：
//
//分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类
//
//多态的优点：
//
//* 代码组织结构清晰
//* 可读性强
//* 利于前期和后期的扩展以及维护
class calculator
{
public:
	int getanwser1(string oper)
	{
		if (oper == "+")
		{
			return m_a + m_b;
		}
		else if(oper == "-")
		{
			return m_a - m_b;
		}
		else if(oper == "*")
		{
			return m_a * m_b;
		}
		else if (oper == "/")
		{
			return m_a / m_b;
		}
	}
	//如果想扩展新的计算器功能，就需要修改源码int getanwser(string oper)
	//真正开发中，提倡一种原则---开闭原则
	//对扩展进行开放，对修改进行关闭
	int m_a; //操作数1
	int m_b; //操作数2
};



void test53()
{
	//创建计算器对象
	calculator p;
	p.m_a = 10;
	p.m_b = 10;
	cout << p.getanwser1("+") << endl;
	cout << p.getanwser1("-") << endl;
	cout << p.getanwser1("*") << endl;
	cout << p.getanwser1("/") << endl;

}

//利用多态实现计算器
//好处 ：
//1.组织结构清晰
//2.可读性强
//3.对于后期和前期扩展及维护性能强
//总结：C++开发提倡利用多态设计程序架构，因为多态优点很多
//实现计算器抽象类
class Acalculator
{
public:
	virtual int getanwser()
	{
		return 0;
	}
	int a;
	int b;

};
//加法计算器
class add : public Acalculator
{
public:
	int getanwser()
	{
		return a + b;
	}
};
//减法计算器
class jian :public Acalculator
{
	int getanwser()
	{
		return a - b;
	}
};


void test54()
{
	//多态使用条件
	//父类指针或者引用指向子类对象
	Acalculator* p = new add;
	p->a = 10; 
	p->b = 10;
	cout << p->getanwser() << endl;
	//用完后记得销毁
	delete p;

	//减法运算

	p = new jian;
	cout << p->getanwser() << endl;
	//用完后记得销毁
	delete p;

}
int main()
{
	
	test53();
	test54();
	system("pause");
	return 0;
}
4.7.3 纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

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

当类中有了纯虚函数，这个类也称为抽象类

抽象类特点：

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

示例：

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

//纯虚函数和抽象类
class base
{
	//纯虚函数
	//类中只要有一个纯虚函数就称为抽象类
	//1.抽象类无法实例化对象
	//2.子类必须重写父类中的纯虚函数，否则也属于抽象类
public:
	virtual void func() = 0;
};

class son:public base
{
public:
	void func()
	{
		cout << "子类调用" << endl;
	}
};
void test55()
{
	//base b;//抽象类无法实例化对象   ----栈区
	//new base;//抽象类无法实例化对象   ---堆区
	//子类必须重写父类中的纯虚函数，否则也属于抽象类,否则无法实例化对象
	base* a = new son;
	a->func();
	
}

int main4601()
{

	test55();
	system("pause");
	return 0;
}
4.7.4 多态案例二-制作饮品

案例描述：

制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料

利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

在这里插入图片描述

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




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

//制作饮品抽象类
class AbstractMaking
{
public:
	virtual void zhushui() = 0;//煮水
	virtual void chongpao() = 0;//冲泡
	virtual void daorubeizhong() = 0;//倒入杯中
	virtual void jiarufuliao() = 0;//加辅料
	//制作流程规定
	void dowork()
	{
		zhushui();
		chongpao();
		daorubeizhong();
		jiarufuliao();
	}

};
//制作咖啡
class kafei :public AbstractMaking
{
public:
	virtual void zhushui()
	{
		cout << "煮农夫山泉" << endl;
	}
	virtual void chongpao()
	{
		cout << "冲泡咖啡" << endl;

	}
	virtual void daorubeizhong()
	{
		cout << "倒入杯中" << endl;

	}
	virtual void jiarufuliao()
	{
		cout << "加糖加牛奶" << endl;

	}
};
//制作茶水
class chaye :public AbstractMaking
{
public:
	virtual void zhushui()
	{
		cout << "煮自来水" << endl;
	}
	virtual void chongpao()
	{
		cout << "冲泡茶叶" << endl;

	}
	virtual void daorubeizhong()
	{
		cout << "倒入杯中" << endl;

	}
	virtual void jiarufuliao()
	{
		cout << "加柠檬" << endl;

	}
};
//具体实现函数
void test56(AbstractMaking* dringk)
{
	dringk->dowork();
	delete dringk;
}


//测试函数
void test57()
{
	test56(new kafei);//制作咖啡
	cout << "--------------" << endl;
	test56(new chaye);//制作茶叶
}
int main()
{

	test57();
	system("pause");
	return 0;
}
4.7.5 虚析构和纯虚析构

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

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

虚析构和纯虚析构共性：

  • 可以解决父类指针释放子类对象
  • 都需要有具体的函数实现

虚析构和纯虚析构区别：

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

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名() = 0;

类名::~类名(){}

示例：

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


//多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
//解决方式：将父类中的析构函数改为** 虚析构** 或者** 纯虚析构**



//虚析构和纯虚析构共性：
//
//* 可以解决父类指针释放子类对象
//* 都需要有具体的函数实现
//
//虚析构和纯虚析构区别：
//
//* 如果是纯虚析构，该类属于抽象类，无法实例化对象
//虚析构语法：
//
//`virtual ~类名() {}`
//
//纯虚析构语法：
//
//` virtual ~类名() = 0; `
//
//`类名::~类名() {}`
class Animal3
{
public:
	Animal3()
	{
		cout << "Animal3构造函数调用" << endl;
	}
	//1.虚析构函数，可以解决父类指针释放子类对象不干净的问题
	/*virtual~Animal3()
	{
		cout << "Animal3虚析构函数调用" << endl;
	}*/

	//2.纯虚析构函数，可以解决父类指针释放子类对象不干净的问题
	virtual~Animal3() = 0;//纯虚析构需要有声明 和 实现  
	//如果是纯虚析构，该类属于抽象类，无法实例化对象


	//纯虚函数
	virtual void speak() = 0;
};

Animal3::~Animal3()
{
	cout << "Animal3纯虚析构函数调用" << endl;
}

class cat11 : public Animal3
{
public:
	
	virtual void speak()
	{
		cout << *name <<"小猫在说话" << endl;
	}
	cat11(string name)
	{
		this->name = new string(name);
		cout << "cat构造函数调用" << endl;
	}
	~cat11()
	{
		if (name != NULL)
		{
			cout << "cat析构函数调用" << endl;
			delete name;
			name = NULL;
		}
	}
	string* name;
};

void test56()
{
	
	Animal3 * p = new cat11("tom");
	p->speak();
	//父类指针在析构时候不会调用子类中析构函数 导致子类中如果有堆区属性，会出现内存泄漏情况
	delete p;
}
int main()
{

	test56();
	system("pause");
	return 0;
}

总结：

​ 1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象

​ 2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构

​ 3. 拥有纯虚析构函数的类也属于抽象类

4.7.6 多态案例三-电脑组装

案例描述：

电脑主要组成部件为 CPU（用于计算），显卡（用于显示），内存条（用于存储）

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

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

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

在这里插入图片描述

#include<iostream>
#include<string>
using namespace std;
//#### 4.7.6 多态案例三-电脑组装
//**案例描述：**
//
//电脑主要组成部件为 CPU（用于计算），显卡（用于显示），内存条（用于存储）
//
//将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商
//
//创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
//
//测试时组装三台不同的电脑进行工作

//抽象cpu类
class CPU
{
public:
	//抽象计算函数
	virtual void caculate() = 0;
};

//抽线显卡类
class xianka
{
public:
	//抽象现实函数
	virtual void display() = 0;

};

//抽象内存条类
class neicuntiao
{
public:
	//抽象存储函数
	virtual void storage() = 0;
};

//电脑类
class cumpter
{
public:
	//构造函数中传入三个零件的指针
	cumpter(CPU* cpu, xianka* xianka, neicuntiao* neicuntiao)
	{
		m_cpu = cpu;
		m_xianka = xianka;
		m_neicuntiao = neicuntiao;
	}

	//提供一个工作的函数，调用每个零件工作的借口
	void work()
	{
		m_cpu->caculate();
		m_xianka->display();
		m_neicuntiao->storage();
	}
	~cumpter()
	{
		if (m_cpu != NULL)
		{
			delete m_cpu; 
			m_cpu = NULL;
		}
		if (m_xianka != NULL)
		{
			delete m_xianka;
			m_xianka = NULL;
		}
		if (m_neicuntiao != NULL)
		{
			delete m_neicuntiao;
			m_neicuntiao = NULL;
		}
	}
private:
	CPU* m_cpu;
	xianka* m_xianka;
	neicuntiao* m_neicuntiao;
};


//Intercpu   零件厂商
class InterCpu : public CPU
{
public:
	//重写计算函数
	virtual void caculate()
	{
		cout << "Inter cpu 开始计算了" << endl;
	}
};
//Inter显卡    零件厂商
class Interxianka : public xianka
{
public:
	//重写显示函数
	virtual void display()
	{
		cout << "Inter 显卡 开始显示了" << endl;
	}
};
//Inter 内存条   零件厂商
class Interneicuntiao : public neicuntiao
{
public:
	//重写存储函数
	virtual void storage()
	{
		cout << "Inter 显卡 开始显示了" << endl;
	}
};




//Lenovocpu   零件厂商
class LenovoCpu : public CPU
{
public:
	//重写计算函数
	virtual void caculate()
	{
		cout << "Lenovo cpu 开始计算了" << endl;
	}
};
//Lenovo显卡    零件厂商
class Lenovoxianka : public xianka
{
public:
	//重写显示函数
	virtual void display()
	{
		cout << "Lenovo 显卡 开始显示了" << endl;
	}
};
//Lenovo 内存条   零件厂商
class Lenovoneicuntiao : public neicuntiao
{
public:
	//重写存储函数
	virtual void storage()
	{
		cout << "Lenovo 显卡 开始显示了" << endl;
	}
};


void test58()
{
	//第一台电脑零件
	CPU* cpu = new InterCpu;
	xianka* xianka = new Interxianka;
	neicuntiao* neicuntiao = new Interneicuntiao;


	//第一台电脑工作
	cout << "第一台电脑开始工作：" << endl;
	cumpter* p1 = new cumpter(cpu, xianka, neicuntiao);
	p1->work();
	delete p1;
	cout << "-----------------------" << endl;




	//第二台电脑工作
	cout << "第二台电脑开始工作：" << endl;
	cumpter* p2 = new cumpter(new LenovoCpu,new  Lenovoxianka, new  Lenovoneicuntiao);
	p2->work();
	delete p2;
	cout << "-----------------------" << endl;

	//第三台电脑工作
	cout << "第三台电脑开始工作：" << endl;
	cumpter* p3 = new cumpter(new InterCpu, new  Lenovoxianka, new  Lenovoneicuntiao);
	p3->work();
	delete p3;

}


int main()
{

	test58();
	system("pause");
	return 0;
}

5 文件操作

程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放

通过文件可以将数据持久化

C++中对文件操作需要包含头文件 < fstream >

文件类型分为两种：

  1. 文本文件 - 文件以文本的ASCII码形式存储在计算机中
  2. 二进制文件 - 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们

操作文件的三大类:

  1. ofstream：写操作
  2. ifstream： 读操作
  3. fstream ： 读写操作

5.1文本文件

5.1.1写文件

写文件步骤如下：

  1. 包含头文件

    #include <fstream>

  2. 创建流对象

    ofstream ofs;

  3. 打开文件

    ofs.open(“文件路径”,打开方式);

  4. 写数据

    ofs << “写入的数据”;

  5. 关闭文件

    ofs.close();
    文件打开方式：

打开方式解释
ios::in为读文件而打开文件
ios::out为写文件而打开文件
ios::ate初始位置：文件尾
ios::app追加方式写文件
ios::trunc如果文件存在先删除，再创建
ios::binary二进制方式

注意： 文件打开方式可以配合使用，利用|操作符

**例如：**用二进制方式写文件 ios::binary | ios:: out

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

//C++中对文件操作需要包含头文件 <fstream>
//文件类型分为两种：
//1. * *文本文件 * *-文件以文本的 * *ASCII码 * *形式存储在计算机中
//2. * *二进制文件 * *-文件以文本的 * *二进制 * *形式存储在计算机中，用户一般不能直接读懂它们
//
//操作文件的三大类:
//1. ofstream：写操作
//2. ifstream： 读操作
//3. fstream ： 读写操作

//### 5.1文本文件
//
//#### 5.1.1写文件
//
//写文件步骤如下：
//
//1. 包含头文件
//#include <fstream>
//
//2. 创建流对象
//ofstream ofs;
//
//3. 打开文件
//ofs.open("文件路径", 打开方式);
//
//4. 写数据
//ofs << "写入的数据";
//
//5. 关闭文件
//ofs.close()文件打开方式：

//| 打开方式 | 解释                       |
//| ---------- - | -------------------------- |
//| ios::in | 为读文件而打开文件         |
//| ios::out | 为写文件而打开文件         |
//| ios::ate | 初始位置：文件尾           |
//| ios::app | 追加方式写文件             |
//| ios::trunc | 如果文件存在先删除，再创建 |
//| ios::binary | 二进制方式 |


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


void test599()
{
	//1.包含头文件 fstream

	//2.创建流对象
	ofstream ofs;

	//3.指定打开方式
	//ofs.open("test.txt", ios::out);  //不指定目录，直接写文件名称"test.txt"，就会创建在与脚本文件同级别路径下

	//4.写内容

	ofs << "张三Å李四" << "男人" << endl;
	ofs << "张三Å李四" << "男人" << endl;
	ofs << "张三Å李四" << "男人" << endl;

	//5.关闭文件

	ofs.close();
}
int main()
{

	test599();
	system("pause");
	return 0;
}

总结：

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

读文件与写文件步骤相似，但是读取方式相对于比较多

读文件步骤如下：

  1. 包含头文件

    #include <fstream>

  2. 创建流对象

    ifstream ifs;

  3. 打开文件并判断文件是否打开成功

    ifs.open(“文件路径”,打开方式);

  4. 读数据

    四种方式读取

  5. 关闭文件

    ifs.close();

示例：

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


//读文件

void test68()
{
	//1.包含头文件

	//2.创建流对象
	ifstream ifs;

	//3.打开文件，并判断是否打开成功
	ifs.open("test.txt",ios::in);
	
	if (!ifs.is_open())//ifs.is_open()返回bool类型，成功打开返回真，失败返回0
	{
		cout << "文件打开失败" << endl;
		return;
	}
	//4.读数据

	//第一种
	//char buf[1024] = { 0 };
	//while (ifs >> buf)//从文件读入，直到读不到数据返回0
	//	{
	//		cout << buf << endl;
	//	}


	//第二种
	//char buf[1024] = { 0 };
	//while (ifs.getline(buf,sizeof(buf)))//getline（）获取
	//{
	//	cout << buf << endl;
	//}

	//第三种
	//string  buf;
	//while (getline(ifs, buf))//getline（）获取
	//{
	//	cout << buf << endl;
	//}

	//第四种  --不建议用（把文件中所有数据一个一个字符读出来）
	char c;
	while ((c = ifs.get()) != EOF )  //EOF  代表 end of file  文件尾 
	{
		cout << c;
	}




	//5.关闭文件
	ifs.close();
}

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

总结：

  • 读文件可以利用 ifstream ，或者fstream类
  • 利用is_open函数可以判断文件是否打开成功
  • close 关闭文件

5.2 二进制文件

以二进制的方式对文件进行读写操作

打开方式要指定为 ios::binary

5.2.1 写文件

二进制方式写文件主要利用流对象调用成员函数write

函数原型 ：ostream& write(const char * buffer,int len);

参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数

示例：

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


class Person99
{
public:
	char name[64];  //姓名	
	int age;//年龄
};
void test699()
{
	//1.包含头文件 fstream

	//2.创建流对象
	//ofstream ofs1;

	//3.指定打开方式
	//ofs.open("Person99txt", ios::out | ios::binary );  //不指定目录，直接写文件名称"test.txt"，就会创建在与脚本文件同级别路径下



	//也可以直接合并23
	ofstream ofs("Person99.txt", ios::out | ios::binary);
	//4.写内容
	Person99 p = { "张三", 18 };
	ofs.write((const char*)&p,sizeof(Person99));

	//5.关闭文件

	ofs.close();
}


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

总结：

  • 文件输出流对象 可以通过write函数，以二进制方式写数据
#include<iostream>
#include<string>
#include<fstream>
using namespace std;

//读文件
class Person99
{
public:
	char name[64];  //姓名	
	int age;//年龄
};

void test689()
{
	//1.包含头文件

	//2.创建流对象
	ifstream ifs;

	//3.打开文件，并判断是否打开成功
	ifs.open("Person99.txt", ios::in | ios::binary);


	if (!ifs.is_open())//ifs.is_open()返回bool类型，成功打开返回真，失败返回0
	{
		cout << "文件打开失败" << endl;
		return;
	}
	//4.读数据
	Person99 p;

	ifs.read((char* )&p, sizeof(Person99));

	cout << "xingming" << p.name << "nianling" << p.age << endl;


	//5.关闭文件
	ifs.close();
}

int main()
{
	test689();
	system("pause");
	return 0;
}
//总结：

//*文件输出流对象 可以通过write函数，以二进制方式写数据
J_bz_Redio
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习笔记（十）（多态，文件操作）
qq_40694605的博客
02-27 500
本笔记主要来源于教程https://www.bilibili.com/video/av41559729?p=1 4.7 多态 多态是C++面向对象三大特性之一 多态分为两类： 静态多态：函数重载 和 运算符重载 属于静态多态，复用函数名 动态多态：派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多态的函数地址早绑定–编译阶段确认函数地址 动态多态的函数地址晚绑定–运行阶段确认函数...
C++ 职工/学生管理系统（类的多态和文件读写操作）
08-12
基于C++类的多态和文件读写操作所编写的管理系统，可以将输入的信息进行保存到本地的txt文本或其他格式的文件中。 具体的功能如下： 1.展示界面菜单 2.添加职工/学生信息 3.显示职工/学生信息 4.删除职工/学生信息 5...
用c++写一个最简单的内核（只有几百行代码，编译通过）
04-08
用c++写一个最简单的内核（只有几百行代码，编译通过）
C++——面向对象编程（文件 多态 继承）完善中
weixin_45683677的博客
03-04 223
1.面向对象编程的特性 程序由类(class)构成，基本特征为封装性、继承性和多态性. 2.c++文件的使用 1.打开文件 一般使用的头文件 fstream类都有一个函数 ????为了写的out与为了读的in 是相对于程序而言的???? void open(const char* filename,int mode,int access); fstream file1; file1.open("c:conf...
类的继承，文件读写
weixin_30909575的博客
07-31 100
父类 package hh; public class People { protected String name; protected int age=16; public String getName() { return name; } public void setName(String name) { this.name = name; } public voi...
C++ 二进制文件流读写包含多态的派生类 #1
先闻其声的博客
06-28 331
二进制文件的优势在于效率高，占用小，但不可直接读取，对于量大又需要隐藏信息的存储来说很实用。既然是读写内存数据流，那我们就可以对类对象进行读写操作，而派生类只是有点小不同。 先写好派生类： class a { public: int m; a() {} a(int m1) { m = m1; } virtual void MsgBox() { cout << "...
C++核心编程——多态和文件操作
qq_43718691的博客
03-14 823
一、多态 1.1多态得基本概念 多态分为两类 1、静态多态：函数重载和运算符重载属于静态多态复用函数名 2、动态多态：派生类和虚函数实现运行多态 静态多态和动态多态区别 静态多态得函数地址找早绑定——编译阶段确定函数地址 动态多态得函数地址晚绑定——运行阶段确定函数地址 总结：多态满足条件 1、有继承关系 2、子类重写父类中得虚函数 多态使用条件：1、父类指针或引用指向子类对象 重写：函数返回值类型函数名参数列表完全一致称为重写 //如果想扩展新的功能需求修改源码、在开发中提倡开闭原则
C++-05继承和多态
03-11
C++继承和多态的学习笔记
C语言模式实现C++继承和多态的实例代码
08-29
本篇文章主要介绍了C语言模式实现C++继承和多态的实例代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
内存读写驱动的源码(C++)
01-04
内存读写驱动的源码(C++)
浅谈c++的精髓之继承和多态
09-10
浅谈c++的精髓之继承和多态
C语言实现C++继承和多态的代码分享
08-29
本文主要给大家简单讲诉了C和C++的区别以及如何使用C语言模拟实现C++继承和多态，并附上示例代码，是篇相当不错的文章，推荐给喜欢C语言的小伙伴们
内核下读写文件
specialsun的专栏
01-11 244
内核中操作文件函数与用户层read，write这样API不同，需要使用内核空间专用的一套函数。   文件API struct file *filp_open(const char *filename, int flags, int mode); 打开文件 int filp_close(struct file *filp, fl_owner_t id); 关闭文件，参数id为POSI...
c++学习心得第二期 多态+文件操作
qq_37448336的博客
10-06 914
c++学习心得第二期 多态+文件操作一、pandas是什么？1、多态的基本概念2、多态案例一-计算器类3、纯虚函数和抽象类4、多态案例二-制作饮品5、虚析构和纯虚析构6、多态案例三-电脑组装二、文件操作1.文本写文件2.文本读文件3、二进制文件4、二进制写文件5、二进制读文件 一、pandas是什么？ 1、多态的基本概念 多态是C++面向对象三大特性之一 多态分为两类 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名 动态多态: 派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多
基于C语言+AT89C52单片机搭建的PID直流电机控制程序，用于Proteus电路仿真+源码+开发文档（高分优秀项目）
最新发布
05-31
基于C语言+AT89C52单片机搭建的PID直流电机控制程序，用于Proteus电路仿真+源码+开发文档，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 项目简介： 本文所介绍的基于AT89C52单片机的PID直流电机控制系统设计过程主要分为MATLAB建模、Proteus硬件电路的设计以及基于C51语法的单片机程序开发编写。本系统性质为单闭环控制，即通过转速对电机进行调速；将采用增量式编码器进行电机转速的测量，并设定PWM波形生成的开关频率为7KHz，速度回路的采样周期为14ms。 1. 所需仿真平台 单片机部分代码主要利用Keil uVision5平台进行编译，工具链采用C51。仿真电路搭建平台为Proteus 8 Professional。 2. Release版本 编译后的运行环境为Atmel AT89C52单片机平台。 3. 运行 将已发布的HEX文件放入Proteus 8 Professional仿真平台或以上版本内运行即可； 可通过修改Proteus仿真文件方波的频率（开关频率）来改变PWM相应的频率；
基于.net8的物料管理系统
05-31
{FB0886BF-35E0-480F-8B15-E4D52B351628}
Java开发案例-springboot-32-整合sharding-jdbc-源代码+文档.rar
05-31
Java开发案例-springboot-32-整合sharding-jdbc-源代码+文档.rar Java开发案例-springboot-32-整合sharding-jdbc-源代码+文档.rar Java开发案例-springboot-32-整合sharding-jdbc-源代码+文档.rar Java开发案例-springboot-32-整合sharding-jdbc-源代码+文档.rar Java开发案例-springboot-32-整合sharding-jdbc-源代码+文档.rar Java开发案例-springboot-32-整合sharding-jdbc-源代码+文档.rar Java开发案例-springboot-32-整合sharding-jdbc-源代码+文档.rar
微信小程序-模仿知乎.rar
05-31
微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎.rar微信小程序-模仿知乎
C++类的继承与多态
07-27
\[3\]继承和多态是C++中重要的概念，多态可以通过虚函数实现，使得不同的派生类对象可以以相同的方式进行操作。 #### 引用[.reference_title] - *1* [C++ 继承与多态]...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值