[c++学习笔记10]：类和对象——继承

最新推荐文章于 2024-05-21 11:17:04 发布
最新推荐文章于 2024-05-21 11:17:04 发布
阅读量176 收藏 1
点赞数
分类专栏： c++ 文章标签： 类 cpp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dinnersize/article/details/106034127
版权

有些类与类之间存在特殊的关系。
我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。
这个时候我们就可以考虑利用继承的技术，减少重复代码。
继承的好处：
++可减少重复代码++

一、基本语法

class A : public B;
A 类称为子类 或 派生类
B 类称为父类 或 基类

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

接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处。
普通实现：（繁琐，难以实现，内容复杂，低级程序员）

//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;
}

但是运用继承的话：
通过继承，减少很多代码量，就很舒服。

#include<iostream>
using namespace std;
#include<string>
//函数调用()运算符重载
class Basetool
{
public:
	void head()
	{
		cout << "页面设置，详情信息……（头部信息）" << endl;
	}
	void foot()
	{
		cout << "合作方式，快速加入……（底部信息）" << endl;
	}
	void left()
	{
		cout << "c++,python,java……(左侧信息)" << endl;
	}
};
class python: public Basetool
{
public:
	void content()
	{
		cout << "python的界面（内容信息）……" << endl;
	}
};
class cpp : public Basetool
{
public:
	void content()
	{
		cout << "c++的界面（内容信息）……" << endl;
	}
};
class java : public Basetool
{
public:
	void content()
	{
		cout << "java的界面（内容信息）……" << endl;
	}
};
void test01() 
{
	python py;
	py.head();
	py.foot();
	py.left();
	py.content();
	cout << "+++++++++++++++++++++++" << endl;
	cpp cp;
	cp.head();
	cp.foot();
	cp.left();
	cp.content();
	cout << "+++++++++++++++++++++++" << endl;
	java y;
	y.head();
	y.foot();
	y.left();
	y.content();
	cout << "+++++++++++++++++++++++" << endl;

}


int main() {

	test01();

	system("pause");

	return 0;
}

总结：

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

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

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

二、继承的方式

继承方式一共有三种：

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

逻辑如图：在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
//函数调用()运算符重载
class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
//公共继承
class Son1 : public Base
{
public:
	void func()
	{
		m_A=32 ; //可访问 public权限
		m_B=3 ; //可访问 protected权限，类外不可访问，在继承中，儿子可以访问父亲
		//m_C; //不可访问
	}
};

void test01() 
{
	Son1 s1;
	s1.m_A = 78;//其他类只能访问到公共权限
	//s1.m_B=2    保护权限类外不可访问，


}
class Son2 : protected Base
{
public:
	void func()
	{
		m_A; //可访问 private权限，父类中public成员到子类变为protected成员
		m_B; //可访问 private权限，父类中protected成员到子类变为protected成员
		//m_C; //不可访问
	}
};
void test02() 
{
	Son2 s;
	//s.m_A; //不可访问
}
class Son3 :private Base
{
public:
	void func()
	{
		m_A; //可访问 private权限，父类中public成员到子类变为private成员
		m_B; //可访问 private权限，父类中protected成员到子类变为private成员
		//m_C; //不可访问
	}
};
void test03()
{
	Son3 f;
	//Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
	//m_A;
	//m_B;
	//m_C;
}
class grandson : public Son3
{
public:
	void func()
	{
		m_A = 1;//到了Son3中，m_A,m_B变成了私有，即时是儿子，也访问不到。
		m_B = 2;
	}
};

int main() {

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

三、继承中的对象模型

使用开发人员命令工具
进行操作。首先切换到本目录
然后：
cl /d1 reportSingleClassLayoutSon hello.cpp
报告单个类的布局+类名。
(tap键可补齐)
我们发现：
继承后，父类的所有都来了包括私有，也占用空间。

>父类中所有非静态成员都被继承下去了
>父类中私有成员被编译器隐藏了，因此访问不到，但是确实被继承下去了。

#include<iostream>
using namespace std;
#include<string>
//函数调用()运算符重载
class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
//公共继承
class Son : public Base
{
public:
	int m_D;
};
void test01()
{
	//16
	//父类中所有非静态成员都被继承下去了
	//父类中私有成员被编译器隐藏了，因此访问不到，但是确实被继承下去了。
	cout << "子类的大小" << sizeof(Son) << endl;
}
int main() {

	test01();
	//test02();

	system("pause");

	return 0;
}

查看对象模型如图：
在这里插入图片描述

四、继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数。
顺序：
先有父亲，后有儿子，然后儿子先死（英年早逝），父亲后死。
白发人送黑发人。

#include<iostream>
using namespace std;
#include<string>
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();
	//test02();

	system("pause");

	return 0;
}

在这里插入图片描述

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

五、继承同名成员处理方式

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域
    //同名成员属性
void test01()
{
	Son s;
	cout << "son: m_A" << s.m_A << endl;
	//如果通过子类对象，访问到父类中的同名成员，需要加作用域
	cout << "Base: m_A" << s.Base::m_A << endl;
}
//同名成员函数
void test02()
{
	Son s2;
	s2.func();//直接调用，调用的是子类中的同名成员

	//调用父类的同名成员
	s2.Base::func();

	//如果子类出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有的同名成员函数（包括重载版本），
	//如果想访问到父类的成员，需要加上作用域。
	s2.Base::func(2);

}

总代码：

#include<iostream>
using namespace std;
#include<string>
//继承同名成员处理
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 = 1230;
	}
	void func()
	{
		cout << "Son func()的调用" << endl;
	}
	int m_A;

};
//同名成员属性
void test01()
{
	Son s;
	cout << "son: m_A" << s.m_A << endl;
	//如果通过子类对象，访问到父类中的同名成员，需要加作用域
	cout << "Base: m_A" << s.Base::m_A << endl;
}
//同名成员函数
void test02()
{
	Son s2;
	s2.func();//直接调用，调用的是子类中的同名成员

	//调用父类的同名成员
	s2.Base::func();

	//如果子类出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有的同名成员函数（包括重载版本），
	//如果想访问到父类的成员，需要加上作用域。
	s2.Base::func(2);

}
int main() {

	test01();
	test02();

	system("pause");

	return 0;
}

总结：

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

六、同名静态成员处理

静态成员：
静态成员变量
*1.所有对象共享同一份数据，同时被改变
*2.在编译阶段分配内存
*3.类内声明，类外初始化
*4.静态成员变量也有访问权限静态成员和非静态成员出现同名，处理方式一致
静态成员函数
//1.所有对象共享一个函数
//2.静态成员函数只能访问静态成员变量
静态成员函数也有访问权限

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域
#include<iostream>
using namespace std;
#include<string>
//继承同名成员处理
class Base
{
public:

	static void func()
	{
		cout << "static Base func()的调用" << endl;
	}
	static void func(int a)
	{
		cout << "static Base func(int a )【重载】的调用" << endl;
	}
	static int m_A;
};
int Base::m_A = 13;
class Son : public Base
{
public:


	static void func()
	{
		cout << "static Son func()的调用" << endl;
	}
	static int m_A;
};
int Son::m_A = 199;

//同名成员属性
void test01()
{
	//通过对象访问
	Son s;
	cout << "通过对象访问" << endl;
	cout << "static son: m_A" << s.m_A << endl;
	//如果通过子类对象，访问到父类中的同名成员，需要加作用域
	cout << "static Base: m_A" << s.Base::m_A << endl;
	cout << "通过类名访问" << endl;
	cout << "static son: m_A" << Son::m_A << endl;
	cout << "static Base: m_A" << Son::Base::m_A << endl;

}
//同名成员函数
void test02()
{
	Son s2;
	//通过对象访问
	cout << "通过对象访问" << endl;
	s2.func();//直接调用，调用的是子类中的同名成员

	//调用父类的同名成员
	s2.Base::func();

	//如果子类出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有的同名成员函数（包括重载版本），
	//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
	s2.Base::func(2);
	cout << "通过类名访问" << endl;
	Son::func();
	Son::Base::func();
	Son::Base::func(3);
}
int main() {

	test01();
	test02();

	system("pause");

	return 0;
}

在这里插入图片描述

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

七、多继承语法

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

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

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

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

代码：

#include<iostream>
using namespace std;
#include<string>
//多继承语法
class Base1
{
public:
	int m_A = 100;
};
class Base2
{
public:
	int m_A = 200;//开始是m_B 不会出问题，但是改为mA就会出现不明确,要加作用域
};
class Son : public Base1,public Base2
{
public:
	int m_C = 300;
	int m_D = 400;
};

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

	test01();
	//test02();

	system("pause");

	return 0;
}

报告单个类的布局结果

在这里插入图片描述

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

八、菱形继承问题以及解决办法

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

羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生**二义性。**
  1. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

解决办法：
虚继承
//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类,所有继承中同名数据变成同一份数据，可以zuo一次更改。

class Animal
{
public:
	int m_Age ;
};
//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类,所有继承中同名数据变成同一份数据
class Sheep :virtual public Animal{};
class Tuo :virtual public Animal {};
class Sheeptuo : public Sheep,public Tuo{};

总测试代码：

#include<iostream>
using namespace std;
#include<string>
//多继承中的菱形继承问题
class Animal
{
public:
	int m_Age ;
};
//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类,所有继承中同名数据变成同一份数据
class Sheep :virtual public Animal{};
class Tuo :virtual public Animal {};
class Sheeptuo : public Sheep,public Tuo{};
void test01()
{
	Sheeptuo s;
	//s.m_Age = 12;
	s.Sheep::m_Age = 100;
	s.Tuo::m_Age = 300;
	cout << "sheep的age: " << s.Sheep::m_Age << endl;
	cout << "tuo的age: " << s.Tuo::m_Age << endl;
	cout << "Sheeptuo的age: " << s.m_Age << endl;
}
int main() {

	test01();
	//test02();

	system("pause");

	return 0;
}

总结：

  • 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
  • 利用虚继承可以解决菱形继承问题。
荏苒冬春去^
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深度探索c++对象模型-13-单类单继承下的数据成员布局
FairLikeSnow的博客
07-24 104
一、单个类带虚函数的数据成员布局 class MYCLASS { public: int m_i; int m_j; virtual void myvirfunc() { } MYCLASS() { int abc = 1; } ~MYCLASS() { int abc = 1; } }; void main() { cout << sizeof(MYCLASS) << endl; printf("m_i:%d\n", &MYCLASS
C++类的内存布局
qq_40438388的博客
09-16 800
C++中类的地址
C++类对象的内存布局
好记性不如写博客！
10-29 7288
1、C++类对象的内存布局 在C++的类对象中，有两种类的成员变量：static和非static，有三种成员函数：static、非static和virtual。那么，它们在C++的内存中是如何分布的呢？ C++程序的内存格局通常分为四个区：全局数据区(data area)，代码区(code area)，栈区(stack area)，堆区(heap area)(即自由存储区...
C++学习笔记——类和对象——继承
潘芝的博客
02-27 211
继承是面向对象的三大特性之一，下图展示了一些类与类之间的关系。 可以看出来，下层级别的成员除了拥有上一层的共性，还有自己的特性，这个时候就需要考虑用继承的技术以减少重复代码。 继承的语法： class A: 继承方式 B； A类称为子类或者派生类，B类称为父类或者基类，子类中的成员包含两个部分，一部分是从父类继承过来的，另一部分是自己增加的成员，从父类继承过来的表现共性，新增的成员体...
C++学习笔记——类继承
华数云图小分队的博客
01-11 901
通过继承和多态性的机制，基类和派生类之间建立了一种强大的关系，使得面向对象程序具有更好的可维护性和可扩展性。通过使用基类指针或引用来引用派生类的对象，可以以相同的方式调用基类的成员函数，从而实现代码的灵活性和可扩展性。因此，在分析成本和评估绩效时，要以客户为中心，关注他们的需求和反馈，并根据客户的需求来制定产品和服务的设计、生产和销售策略。强调活动的重要性：企业的成本和绩效不仅取决于产品和服务本身，还受到生产和销售过程中的各种活动的影响。关键字，派生类将继承基类的保护成员，并将其作为自己的保护成员。
C++学习笔记——继承和动态内存分配
华数云图小分队的博客
01-11 1004
C++学习笔记——继承和动态内存分配——继承和动态内存分配是C++中两个重要的概念。
【C++】学习笔记——类和对象_1
m0_69828905的博客
04-18 1000
class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者成员函数。class Datepublic:// 这里是不是看的非常迷？day = day;int month;int day;return 0;
C++学习笔记18-类和对象-继承
拒绝任何因懒惰而生的省略号
03-08 655
类和对象-继承18.0 前言18.1 继承的基本语法18.2 继承方式18.3 继承中的对象模型 18.0 前言 继承是面向对象三大特性之一。 有些类与类之间存在特殊的关系，例如下图中: 我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。 这个时候我们就可以考虑利用继承的技术，减少重复代码。 18.1 继承的基本语法 例如我们看到很多网站中，都有公共的头部，公共的底部，甚季公共的左侧列表，只有中心内容不同。 接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看下继承存
C++学习笔记——结构体和类
liangjian990709的博客
01-04 1206
结构体和类 定义 将多个对象放置到一起视为一个整体 //定义 struct str { int x; double y; }; //声明 struct str; //仅有声明只知道str是一个struct但其内部不知道，此时str是incomplete type //但可以定义str* mystr; 所有结构体的指针大小都一样64位机8个字节 注意： 结构体是翻译单元级一处定义，可以在不同翻译单元里有相同的定义 结构体数据成员的定义为隐式，在构造出对象时再定义，在struct的定义中视
C++学习笔记（21）——继承
最新发布
broken_enginer的博客
05-21 848
继承就是有条件的复用。
最low的职工管理系统（c++面向对象）
dinnersize的博客
06-10 535
c++面向对象部分学完了，做个项目熟悉一下，总体应用了多态，继承，类的方法。 知识补充： //打开方式 ios::trunc 如果存在，删除文件并重新创建 //打开方式 ios::trunc 如果存在，删除文件并重新创建 ofstream ofs(FILENAME,ios::trunc); ofs.close(); 下面进入项目： 我们有5个头文件，如下 WorkerManager.h #pragma once //防止头文件重复包含 #include<iostream&gt
[基于STL的演讲比赛管理系统]c++面向对象小项目
dinnersize的博客
10-29 382
头文件： SpeechManager.h #pragma once #include<iostream> using namespace std; #include<vector> #include<map> class Speaker { public: string m_Name; double m_Score[2]; }; class SpeechManager { public: SpeechManager(); void show_Menu();//显示
[c++学习笔记13]c++提高编程——模板
dinnersize的博客
06-10 336
学习了面向对象编程，现在进入c++提高编程~ 熟悉一下模板，为后面的STL打基础
[c++学习笔记01]阶段一面向过程：基本语法全（有c基础）
dinnersize的博客
03-24 300
在大一下学期学习了c语言，最近又想学一下c++，想提高一下编程功底，在次记录一下在有c基础（及其拙劣）的情况下，自己的编程进阶之路。 sizeof（） 返回字节的大小 short a=10; cout << sizeof(short)<< endl;//2 cout << sizeof(a) << endl;//2 cout << siz...
[c++学习笔记12]：文件操作
dinnersize的博客
05-28 288
今天来学习文件操作。
[c++学习笔记07]：类和对象——对象特性
dinnersize的博客
05-02 281
1.构造函数和析构函数 “恢复出厂设置” 构造函数：初始化 析构函数：清理 如果没有定义的话，编译器自动给你弄，但是是空函数。 //1.1构造函数 //没有返回值，不用写void //函数名与类名相同 //构造函数可以有参数，可以发生重载 //创建对象的时候，构造函数会自动调用，且只调用一次 //1.2析构函数（进行清理的操作） //没有返回值，不用写void //函数名： ~类名 //析构函...
[c++学习笔记23]：map/multimap容器
dinnersize的博客
08-05 275
今天学习map容器！
[c++学习笔记11]：类和对象——多态
dinnersize的博客
05-13 275
今天来学习多态~
[c++学习笔记22]:set/ multiset 容器
dinnersize的博客
07-16 275
1 set基本概念 简介： 所有元素都会在插入时自动被排序 本质： set/multiset属于关联式容器，底层结构是用二叉树实现。 set和multiset区别： set不允许容器中有重复的元素 multiset允许容器中有重复的元素 2 set构造和赋值 功能描述：创建set容器以及赋值 构造： set<T> st; //默认构造函数： set(const set &st); //拷贝构造函数 赋值： set
C++面向对象编程：继承与学习指南
"这篇文档是关于C++编程中面向对象编程的继承概念的学习笔记，主要介绍了C++中的继承机制以及面向对象程序设计的基本思想。同时，文档提到了C++的发展历史，行业地位以及其在不同领域的应用。" 在面向对象编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值