浅学 ----- C++ 继承和多态，文件操作

已于 2022-10-05 18:24:27 修改
阅读量766 收藏
点赞数 3
分类专栏： C++ 文章标签： c++
于 2022-05-07 10:29:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ckk1314520/article/details/124625499
版权

文章目录

继承

继承方式

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

继承方式一共有三种：

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

三种继承方式都不继承父类的私有成员

在这里插入图片描述

公共继承：不改变父类中的成员属性，在父类中成员属性是公共的还是公共的。

保户继承：将父类中的成员属性变为保护的

私有继承：将父类中的成员属性变为私有的

继承中的对象类型

父类中的私有成员会继承到子类中，只是被隐藏了，不可访问。

（父类中所有非静态成员属性都会被子类继承下去）

#inlcude<iostream>
using namespace std;
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;
}

该程序的输出结果为16，说明子类也继承了父类的私有成员，只是被隐藏起来了，不可访问。

也可以使用工具查看

利用开发人员命令提示工具查看对象模型

跳转盘符

跳转文件路径 cd 具体路径下

查看命名

cl /dl reportSingleClassLayout类名 文件名

继承中构造函数和析构顺序

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

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

#include<iostream>
using namespace std;

//继承中的构造和析构顺序
class Base
{
public:
    Base()
    {
        cout << "Base构造函数!" << endl;
    }
    ~Base()
    {
        cout << "Base析构函数！" <<endl;
    }
};

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

void test01()
{
    //Base b;
    Son s;
}

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

继承中的构造和析构顺序如下：

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

继承同名成员处理方式

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

​ 访问子类同名成员 直接访问即可

​ 访问父类同名成员 需要加作用域

#include<iostream>
using namespace std;

//继承中同名成员处理
class Base
{
public:
    Base()
    {
     	m_A=100; 
    }
    
    void func()
    {
        cout << "Base - func() 调用" << endl;
    }
    
    int m_A; 
};

class Son:public Base
{
public:
    Son()
    {
        m_A=200;
    }
    
    void func()
    {
        cout << "Son - func() 调用" << endl;
    }
    
    int m_A;
};

//同名成员属性（变量）处理
void test01()
{
    Son S;
    cout << "Son  下 m_A = " << s.m_A << ednl;
    //通过子类对象  访问到父类中同名成员，需要加作用域
    cout << "Base 下 m_A = " << s.Base::m_A << endl;
}

//同名成员函数处理
void test02()
{
	Son s;
    s.func();
    s.Base::func();
}

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

子类对象可以直接访问到子类中同名成员

如果子类中出现和父类同名的成员函数，子类的同名成员函数会隐藏掉父类中所有同名成员函数

如果想访问到父类中被隐藏的同名成员函数，需要加作用域

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

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

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

​ 访问子类同名成员 直接访问即可

​ 访问父类同名成员 需要加作用域

#include<iostream>
using namespace std;
class Base
{
 public:
    static int m_A;
    
   	static void func()
    {
        cout<<"Base - static void func()"<<endl;
    }
};
int Base::m_A = 100;

class Son : public Base
{
 public:
    static int m_A;

   	static void func()
    {
        cout<<"Son - static void func()"<<endl;
    }    
};
int Son::m_A = 200;

//同名静态成员属性
void test01()
{
    //1、通过对象访问
    cout << "通过对象访问："<< endl;
    Son s;
    cout << "Son 下 m_A = " << s.m_A << endl;
    cout << "Base 下 m_A = " << s.Base::m_A << endl;
    //2、通过类名访问
    cout << "通过类名访问：" << endl;
 	cout << "Son 下 m_A = " << Son::m_A << endl;
    //第一个::代表通过类名方式访问	第二个::代表访问父类作用域下
    cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

//同名静态成员函数
void test01()
{
    //1、通过对象访问
    Son s;
    s.func();
    s.Base::func();
    //2、通过类名访问
    Son::func();
    Son::Base::func();
}
    
int main()
{
    //test01();
    test02();
    system("pause");
    return 0;
}

多继承语法

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

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

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

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

菱形继承

概念：两个派生类继承同一个基类，又有某个类同时继承这两个派生类，这种继承被称为菱形继承，或者钻石继承

当菱形继承，两个父类拥有相同数据，需要加以作用域区分

利用虚继承 解决菱形继承的问题

继承之前 加上关键字 virtual 变成虚继承 解决了数据有两份的问题

vbptr：v - virtual b - base ptr - pointer 虚基类指针，指向虚基类表（vbtable）

#include<iostream>
using namespace std;
class Animal
{
public:
    int m_Age;
};

//继承前加vritual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : vritual public Animal {};
class Tuo : vritual public Animal {};
Class SheepTuo : public Sheep,public Tuo {};

void test01()
{
    SheepTuo st;
    st.Sheep::m_Age = 100;
    st.Tuo::m_Age = 200;
    
    cout<<"st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
    cout<<"st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
    cout<<"st.m_Age = " << endl;
}

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

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

利用虚继承可以解决菱形继承问题

多态

多态分为两类

​ 静态多态：函数重载 和 运算符重载属于静态多态，复用函数名

​ 动态多态：派生类和虚函数实现运行时多态

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

​ 静态多态的函数地址早绑定 - 编译阶段确定函数地址

​ 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

#include<iostream>
using namespace std;

//多态
//动物类
class Animal
{
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)	
}

动态多态满足条件

1、有继承关系

2、子类重写父类的虚函数

（重写时，virtual 关键字可加可不加）

动态多态使用

父类的指针或者引用 指向子类对象

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

在这里插入图片描述

纯虚函数和抽象类

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

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

纯虚函数语法：vritual返回值类型 函数名 (参数列表) = 0

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

抽象类特点：

​ 无法实例化对象

​ 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

#include<iostream>
using namespace std;

class Base
{
public:
	//纯虚函数
	//只要有一个纯虚函数，这个类称为抽象类
	//抽象类的特点：
	//无法实例化对象 
	virtual void func() = 0;	
	 
};

class Son : public Base
{
public:
	virtual void func()
	{
		cout<<"func函数调用"<<endl;
	}
};

void test01()
{
	Base * base = new Son;
	base->func();
} 

int main()
{
	test01();
	return 0;
}

虚析构和纯虚析构

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

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

虚析构和纯虚析构共性：

​ 可以解决父类指针释放子类对象

​ 都需要有具体的函数实现

虚析构和纯虚析构区别：

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

虚析构语法：

​ virtual ~类名(){}

纯虚析构语法：

​ virtual ~类名() = 0;

​ 类名::~类名(){}

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

class Animal
{
public:
	Animal()
	{
		cout<<"Animal构造函数调用"<<endl;
	}
	

	//利用虚析构可以解决 父类指针释放子类对象时不干净的问题 
	/*virtual ~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 << "Cat构造函数调用" << endl;
		m_Name = new string(name);
	}
	

	virtual void speak()
	{
		cout<<*m_Name<<"小猫在说话"<<endl;
	}
	
	~Cat()
	{
		if(m_Name != NULL)
			{
				cout << "Cat析构函数调用" << endl;
				delete m_Name;
				m_Name = NULL;
			}
	}
	string *m_Name; 

}; 

void test01()
{
	Animal * animal = new Cat("Tom");
	animal->speak();
	//父类指针在析构时候 不会调用子类中析构函数，导致子类如果有堆区属性，出现内存泄露 
	delete animal;
}

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

总结：

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

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

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

文件操作

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

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

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

文件类型分为两种：

​ 1、文本文件 - 文件以文本的ASCII码形式存储在计算机中

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

操作文件的三大类：

​ 1、ofstream：写操作

​ 2、ifstream：读操作

​ 3、fstream：读写操作

文本文件

写文件

写文件步骤如下：

​ 1、包含头文件

​ #include<fstream>

​ 2、创建流对象

​ ofstream ofs;

​ 3、打开文件

​ ofs.open(“文件路径”，打开方式)；

​ 4、写数据

​ ofs << “写入的数据”；

​ 5、关闭文件

​ ofs.close();

文件打开方式：

image-20220507110457404

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

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

生成的文件和源程序文件在同一目录下。

#include<iostream>
#include<fstream>	//头文件包含 
using namespace std;

//文本文件 写文件 
void test01()
{
	//1、包含头文件 fstream
	

	//2、创建流对象
	ofstream ofs; 
	
	//3、指定打开方式
	ofs.open("test.txt",ios::out);
	
	//4、写内容
	ofs << "hello world"<<endl;
	
	//5、关闭文件
	ofs.close(); 

} 

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

读文件

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

读文件步骤如下：

​ 1、包含头文件

​ #include<fstream>

​ 2、创建流对象

​ ifstream ifs;

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

​ ifs.open(“文件路径”，打开方式)

​ 4、读数据

​ 四种方式读取

​ 5、关闭文件

​ ifs.close();

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

//文本文件	读文件
void test01()
{
	//1、包含头文件
	

	//2、创建流对象
	ifstream ifs;
	//3、打开文件 并且判断是否打开成功
	ifs.open("test.txt",ios::in);
	
	if(!ifs.is_open())
	{
		cout << "文件打开失败"<<endl;
		return;
	}
	//4、读数据
	
	//第一种
	/*char buf[1024] = {0};
	while(ifs >> buf)
	{
		cout << buf <<endl;	
	} */
	
	//第二种 
	/*char buf[1024] = {0};
	while(ifs.getline(buf,sizeof(buf)))
	{
		cout << buf <<endl;
	}*/
	
	//第三种
	/*string buf;
	while(getline(ifs,buf))
	{
		cout << buf <<endl;	
	} */
	
	//第四种
	char c;
	while ((c = ifs.get()) != EOF)	//EOF end of file
	{
		cout << c; 	
	} 
	//5、关闭文件
	 ifs.close();

} 

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

总结：

​ 读文件可以利用 ifstream，或者fstream类

​ 利用is_open函数可以判断文件是否打开成功

​ close 关闭文件

二进制文件

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

打开方式指定为 ios::binary

写文件

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

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

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

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

//二进制文件  写文件
class Person
{
public:
	char m_Name[64];	//姓名
	int m_Age;			//年龄 
}; 

void test01()
{
	//1、包含头文件
	//2、创建流对象
	ofstream ofs;
	//3、打开文件
	ofs.open("person.txt",ios::out | ios::binary);
	//4、写文件
	Person p = {"法外狂徒",18};
	ofs.write((const char *)&p,sizeof(Person));
	//5、 关闭文件	
	ofs.close();
} 

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

总结：

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

读文件

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

函数原型：istream& read(char *buffer,int len);

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

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

//二进制文件  写文件
class Person
{
public:
	char m_Name[64];	//姓名
	int m_Age;			//年龄 
}; 

void test01()
{
	//1、包含头文件
	//2、创建流对象
	ifstream ifs;
	//3、打开文件  判断文件是否打开成功 
	ifs.open("person.txt",ios::in | ios::binary);
	if(!ifs.is_open())
	{
		cout << "文件打开失败"<<endl; 
		return;
	}
	//4、读文件
	Person p;
	ifs.read((char *)&p,sizeof(p));
	cout<<"姓名"<<p.m_Name<<"年龄: "<<p.m_Age<<endl; 
	//5、 关闭文件	
	ifs.close();
} 

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

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

@See you later
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
学点c++ 笔记 13 : 类的继承、多态、多文件编译
采菊东篱下
01-25 316
本次练习包含 文件 main.cp、iphone.cpp 、phone.h #include "iphone.h" /* 本次练习类的继承、虚方法重载、调用基类方法、有参构造函数的参数传递 多文件编译 */ int main(int argc, char *argv[]) { //对子类iphone 实例测试 iphone iph5("i5", 5); iph5.selftest(); iphone iph5_2(iph5); iph5_2.selftest() ; // 多态测试 p
【C++】继承/多态/文件
uytguytgf的博客
12-16 470
【C++】继承/多态/文件
C++学习一菱形继承多文件解决方法
HotIce0
02-06 395
当在对象编程时，多把类的定义和声明放在不同文件中，但是如果在菱形继承时，最顶端的基类的头文件会被编译两次，所以会导致类型重复定义。 解决方法：一：在VS2015中可以使用#program once宏来限制编译次数。     二：可能有部分编译器不支持这个宏。那就可以自己用宏定义实现  如下 #ifndef HEADERNAME #define HEADERNAME .......
【C++】—— 继承
M的博客
07-06 653
继承概念的总结
C++面向对象编程 -- 继承、多态和文件操作
小王同学的博客
01-18 2998
面向对象特性；文件操作； 本文为对网络视频学习的个人笔记整理
android-studio图书管理系统
02-27
（7）这篇文章只是为了供一些初学者免费学习（主要是当时哥们交作业的时候没有找到类似的，就浅学了一点点内容然后做出来的，内容肯定不够充实完整），不要不要直接当大作业交上去！！！ 适用读者： 学习移动终端...
跟我学linux-入门级教程
12-31
非常好的教程,浅学易懂,主要是基于centos的讲解
xml浅学笔记
05-15
XML可以保存成独立的 ***.xml 的文件，也可以以字符串的形式出现（服务器端生产） 1、XML的最顶端是XML的声明 <?xml version="1.0" encoding="utf-8" ?> 2、XML标记的语法 1、XML标记必须成对出现 2、...
浅学二极管与三极管
06-24
二极管，三极管，PN接
浅学RC充放电电路
06-24
浅学RC充放电电路
第十二周 静态 +友元 + 动态 + 继承 + 多文件
一只可爱的小猴子的博客
10-23 2662
1.学生类（静态数据成员和静态成员函数） 题目： 定义一个类Student，要求使用静态数据成员或静态成员函数计算全班学生的《计算机导论》课程的总成绩和平均成绩。请同学们自行设计该类。 【提示】 静态数据成员：static int total; 表示所有同学成绩总分 静态成员函数：static void Average(int sum){} 计算sum个学生的平均成绩，主函数在调用的时候采用Student::Average(n)的形式。 【输入形式】 学生姓名 课程成绩 【输出形式】 总成绩和平均成绩 【样
C++多继承
嵌入式与人工智能
02-15 266
C++多继承C++多继承reference C++多继承 #include <iostream> using namespace std; class A { public: void setx(int a){x = a;} int getx(){return x;} private: int x; }; class B { public: void setx(int a){x = a;} int getx(){return x;} private:
＜C++继承与派生＞抽象基类、派生类、纯虚函数、类的头文件
分子six的博客
11-01 1087
C++面向对象程序设计课程的作业。 定义抽象基类 Container, 由它派生出 3 个派生类：Sphere（球体），Cylinder（圆柱体）、Cube（正方体），用虚函数分别计算几种图形的表面积和体积。要求每个类的头文件和成员方法实现文件分开。
C++中的继承
今天你学习了吗？
01-17 490
以下为本人大一时阅读《C++ Primer Plus》中关于继承章节所做的笔记 继承：inheritance 现有的类称为“基类”，继承实现的新类称为“派生类”。（在Java、C#中，基类称为超类，派生类称为子类） 派生类的对象是基类的对象，但基类的对象不是派生类的对象 is-a关系：继承 has-a关系：组成 继承关系定义； 例：类TwoDimensionalShape是由类Shape派生而来的（public继承） class TwoDimensionalShape : publ
继承与头文件
不良少年
12-28 964
一.错误情况       很多人会出现下面这种错误的情况,然后总是找不出原因,我在这里告诉大家到底怎么解决这种难题.为什么会有这样的问题呢,在程序猿写完代码后,感觉一切正常,并没有哪里出错,只是在Xcode中上部位会出现错误,然后就是一通的寻找,后发现程序并没有错误,然后就懵了.        首先会出现这种情况就是因为在创建项目的时候,项目名和继承的对象相符.比如下面的创建项
C++继承
Sabre_Su的博客
04-13 353
当用到C语言的输入输出时：头文件：#include 应该注意string类型并不是基本类型因此当对string类进行输入输出时应该用printf("%s",name.c_str());进行输入输出；另外还需要加入string头文件#include #include #include #include using namespace std; class Person { private:
C++类的继承
成长ing中的w的专栏
08-04 510
本篇介绍C++的类的继承特性。 1.派生类不能继承基类的构造函数、析构函数和拷贝构造函数;基类的重载运算符;基类的友元函数。 2.继承类型：几乎不使用 protected 或 private 继承，通常使用 public 继承。 1）公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。 2）保护继承（protected）： 当一个类派生自保护基类时，
【C++】继承详解
love_guanghui的博客
02-24 1472
继承继承的概念及定义概念定义基类和派生类基类和派生类对象的赋值类型转换继承中的作用域 本文将介绍C++面向对象中三大特性之一的继承，并详细介绍多继承引发的菱形继承及其解决方法。 继承的概念及定义 概念 就像现实世界中子辈继承父辈遗产一样，面向对象的语言一样有继承，这是面向对象程序设计使代码可以复用的最重要的手段。 举个例子，老师和学生都是人，都有人的属性，有姓名，年龄，性别等等公共属性，而如果设计这些对象时在类中都定义相关变量，就会造成数据冗余。所以我们可以将这些共同属性统一为一个类Person，再让St
C++文件操作中的继承关系与Close
DongZhaoCheng
08-17 378
C++文件操作中的继承关系与Close 1.文件流对象—头文件 #include <fstream> #include <ifstream> #include <ofstream> 继承关系 由上述的继承关系可以看出: ifstream、ofstream分别继承自 istream、ostream fstream继承自 iostream，然后 iostream又菱形继承自 istream、ostream 这也就是为什么fstream包含了iostre
cross-attention Transformer
最新发布
09-02
通过对查询向量和键向量进行点积操作，并通过softmax函数获得注意力权重。注意力权重与值向量相乘，并对结果进行求和，得到编码器调整的输出。这样，Cross-Attention机制帮助解码器能够有效地建模当前生成位置的上...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值