C++（九、继承）

最新推荐文章于 2023-10-14 21:46:01 发布
最新推荐文章于 2023-10-14 21:46:01 发布
阅读量200 收藏
点赞数
分类专栏： C++知识总结 文章标签： c++继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44329028/article/details/103001989
版权

c++中的继承

1、继承的概念和定义
2、基类和派生类对象的赋值转换
3、继承中的作用域
4、派生类的默认成员函数
5、继承与友元
6、继承与静态成员
7、复杂的菱形继承

——————————————————————————————

1、继承的概念和定义

继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。

继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。

以前我们接触的复用都是函数复用，继承是类设计层次的复用。

基类的成员变量的无论是什么，都会继承到派生类中，但是 ，派生类不一定能使用继承的成员变量。

继承关系和访问限定符
在这里插入图片描述

继承基类成员访问方式的变化

继承权限–public
基类中public/protected的成员在子类中权限不变
基类中private的成员在子类中不可见(不能用—该成员变量确实已经继承到子类中)
不可见—> 派生类对继承的私有成员不能使用，即使在派生类内部，

在这里插入图片描述
继承方式–protected
基类中public的成员在子类中访问权限已经变成protected
基类中protected的成员在子类中访问权限不变
基类中private的成员在子类中不可见(不能用—该成员变量确实已经继承到子类中)

在这里插入图片描述

继承方式–private
基类中public的成员在子类中访问权限已经变成private
基类中protected的成员在子类中访问权限已经变成private
基类中private的成员在子类中不可见(不能用—该成员变量确实已经继承到子类中)
在这里插入图片描述
class 和 struct的默认继承权限

class默认继承权限—priavet

struct默认继承权限—public

继承权限的验证



#include <iostream>
using namespace std;

#if 0
class Base
{
public:
	void SetBase(int pri, int pro, int pub)
	{
		_pri = pri;
		_pro = pro;
		_pub = pub;
	}

	void PrintBase()
	{
		cout << _pri << endl;
		cout << _pro << endl;
		cout << _pub << endl;
	}

private:
	int _pri;
protected:
	int _pro;
public:
	int _pub;
};

class Derived : public Base
{};

int main()
{
	// 可以验证：派生类将基类中的成员变量继承到子类中
	cout << sizeof(Derived) << endl; //12 ---> 将基类的成员变量继承到子类中

	// 验证：基类中的成员函数是否被子类继承
	Derived d;
	d.SetBase(10, 20, 30);
	d.PrintBase();//
	return 0;
}
#endif

#if 0
// public继承方式：

class Base
{
public:
	void SetBase(int pri, int pro, int pub)
	{
		_pri = pri;
		_pro = pro;
		_pub = pub;
	}

	void PrintBase()
	{
		cout << _pri << endl;
		cout << _pro << endl;
		cout << _pub << endl;
	}

private:
	int _pri;
protected:
	int _pro;
public:
	int _pub;
};

// 继承权限--public
// 基类中public/protected的成员在子类中权限不变
// 基类中private的成员在子类中不可见(不能用---该成员变量确实已经继承到子类中)
class Derived : public Base
{
public:
	void SetDerived(int priD, int proD, int pubD)
	{
		_priD = priD;
		_proD = proD;
		_pubD = pubD;

		_pro = 10;
		// _pri = 20; // 编译报错，在派生类中不能访问基类中私有的成员变量
	}

	// 访问权限：限定该成员变量是否可以直接在类外进行调用
public:
	int _pubD;
protected:
	int _proD;
private:
	int _priD;
};

class D : public Derived
{
public:
	void Test()
	{
		_pro = 10;
	}
};

int main()
{
	Derived d;
	cout << sizeof(d) << endl;

	d._pub = 10;
	// d._pro = 10;
	return 0;
}
#endif


#if 0
class Base
{
public:
	void SetBase(int pri, int pro, int pub)
	{
		_pri = pri;
		_pro = pro;
		_pub = pub;
	}

	void PrintBase()
	{
		cout << _pri << endl;
		cout << _pro << endl;
		cout << _pub << endl;
	}

private:
	int _pri;
protected:
	int _pro;
public:
	int _pub;
};


// 继承方式--protected
// 基类中public的成员在子类中访问权限已经变成protected
// 基类中protected的成员在子类中访问权限不变
// 基类中private的成员在子类中不可见(不能用---该成员变量确实已经继承到子类中)
class Derived : protected Base
{
public:
	void SetDerived(int priD, int proD, int pubD)
	{
		_priD = priD;
		_proD = proD;
		_pubD = pubD;

		_pro = 10;
		// _pri = 20; // 编译报错，在派生类中不能访问基类中私有的成员变量
	}

	// 访问权限：限定该成员变量是否可以直接在类外进行调用
public:
	int _pubD;
protected:
	int _proD;
private:
	int _priD;
};

class D : public Derived
{
public:
	void Test()
	{
		_pub = 10;
		_pro = 20;
	}
};

int main()
{
	Derived d;
	// d._pub = 10;
	return 0;
}
#endif

#if 0
class Base
{
public:
	void SetBase(int pri, int pro, int pub)
	{
		_pri = pri;
		_pro = pro;
		_pub = pub;
	}

	void PrintBase()
	{
		cout << _pri << endl;
		cout << _pro << endl;
		cout << _pub << endl;
	}

private:
	int _pri;
protected:
	int _pro;
public:
	int _pub;
};


// 继承方式--private
// 基类中public的成员在子类中访问权限已经变成private
// 基类中protected的成员在子类中访问权限已经变成private
// 基类中private的成员在子类中不可见(不能用---该成员变量确实已经继承到子类中)
class Derived : private Base
{
public:
	void SetDerived(int priD, int proD, int pubD)
	{
		_priD = priD;
		_proD = proD;
		_pubD = pubD;

		_pro = 10;
		// _pri = 20; // 编译报错，在派生类中不能访问基类中私有的成员变量
	}

	// 访问权限：限定该成员变量是否可以直接在类外进行调用
public:
	int _pubD;
protected:
	int _proD;
private:
	int _priD;
};

class D : public Derived
{
public:
	void Test()
	{
		// _pub = 10;
		//_pro = 20;
	}
};

int main()
{
	Derived d;
	 d._pub = 10;
	return 0;
}
#endif


#if 0
class Base
{
public:
	void SetBase(int pri, int pro, int pub)
	{
		_pri = pri;
		_pro = pro;
		_pub = pub;
	}

	void PrintBase()
	{
		cout << _pri << endl;
		cout << _pro << endl;
		cout << _pub << endl;
	}

private:
	int _pri;
protected:
	int _pro;
public:
	int _pub;
};

 
// class 和 struct的默认继承权限
// class默认继承权限---priavet
// struct默认继承权限---public
struct Derived : Base
{
public:
	void SetDerived(int priD, int proD, int pubD)
	{
		_priD = priD;
		_proD = proD;
		_pubD = pubD;

		_pro = 10;
		// _pri = 20; // 编译报错，在派生类中不能访问基类中私有的成员变量
	}

public:
	int _pubD;
protected:
	int _proD;
private:
	int _priD;
};

class D : public Derived
{
public:
	void Test()
	{
		_pub = 10;
	}
};

int main()
{
	D d;
	d._pub = 10;
	return 0;
}
#endif
2、基类和派生类对象的赋值转换

赋值兼容规则：
前提---->public继承方式

如果是public继承方式：派生类与基类对象之间是–is-a的关系

is-a: 是一个，可以将一个子类对象看成是一个基类对象

1、所有用到基类对象的位置都可以使用子类对象进行代替
在这里插入图片描述

2、一个基类指针可以指向子类对象
一个子类的指针不能直接指向一个基类的对象。

在这里插入图片描述将B类型指针进行强转 B* Bp -----> (A*) Bp （不建议，存在风险）

此时 Bp 就像 A* Ap 一样，访问基类时不会越界访问。

A* Ap 访问派生类因为其本也只会访问与基类相同的部分。

在这里插入图片描述
3、 基类引用可以引用派生类对象，反之不行 ， 因为 引用就是指针。

3、继承中的作用域

同名隐藏：
基类和派生类中具有相同名称的成员(成员变量 || 成员函数)

如果通过派生类对象直接访问同名成员，优先访问到的是派生类自己的。

基类的同名成员不能直接访问到(派生类将基类中的同名成员隐藏)


class B
{
public:
	void SetB(int b)
	{
		_b = b;
	}

	void Test(int a)  // 基类
	{}

// protected:
	char _b;
};



// 成员变量：与变量类型是否相同无关
// 成员函数：与成员函数原型是否相同无关
class D : public B
{
public:
	void SetD(int b, int d)
	{
		_b = b;
	}

	void Test()   // 派生类
	{}

//protected:
	int _b;
};

int main()
{
	cout << sizeof(D) << endl;

	D d;
	d._b = '1';
	d.B::_b = '2';

	d.Test(10);
	d.B::Test(10);

	// d.SetD(1); //   报错 ， 会先从来自于基类中找到，发现没有； 找来自于基类的必须加上 ：： 修饰限定符

	return 0;
}
4、派生类的默认成员函数

1 、如果基类的构造函数是无参或者全缺省的构造函数在派生类构造函

数初始化列表的位置调用或不调用基类构造函数都可以。

如果用户没有调用，则编译器会默认调用。

class B
{
public:
	B() // 基类构造
	{
		cout << "B()" << endl;
	}

protected:
	int _b;
};

class D : public B
{
public:
	D() // 派生构造
	  ：B（）  //基类含有默认的构造函数 编译器默认给出 ，用来初始化继承自基类的成员,
			  //但必须是此时基类必须是默认的构造函数
	  ，_d(2)
	{
		cout << "D()" << endl;
	}

protected:
	int _d;
};

int main()
{
	D d;
	return 0;
}

2、如果基类的构造函数带有参数的构造函数（非默认构造），用户必

须在派生类构造函数初始化列表的位置显式调用，以完成基类部分成

员的初始化.


class B
{
public:
	B(int b)
	{
		cout << "B()" << endl;
	}

protected:
	int _b;
};

class D : public B
{
public:
	D()
		: B(1) // 此时必须显示给出，基类不含默认构造函数
		, _d(2)
	{
		cout << "D()" << endl;
	}

protected:
	int _d;
};

int main()
{
	D d;
	return 0;
}

3、如果基类的构造函数带有参数的构造函数，用户必

须在派生类构造函数初始化列表的位置显式调用，以完成基类 部分成

员的初始化。


3、如果基类的构造函数带有参数的构造函数，用户必须在

派生类构造函数初始化列表的位置显式调用，以完成基类 部分成员的初始化

class D : public B
{
public:
	D(int b, int d)
		: B(b)
		, _d(d)
	{
		cout << "D()" << endl;
	}

	D(const D& d)
		: B(d) // 如何理解将派生类对象d调用基类构造呢？ 派生类可以看成基类
		, _d(d._d)
	{}

	D& operator=(const D& d)
	{
		if (this != &d)
		{
			//*this = d; 导致死循环
			B::operator=(d);
			_d = d._d;
		}

		return *this;
	}
protected:
	int _d;
};

int main()
{
	D d1(1, 2);
	D d2(d1);

	D d3(3, 4);
	d2 = d3; // 赋值，
	return 0;
}



/*

	如果编译器生成默认的构造函数，则编译器生成的构造函数一定是无参的
	Derived()
	   : Base()
	{}
	
	派生类默认构造函数在其初始化列表位置调用基类构造函数时，必须调用基类
	无参或者全缺省的构造函数

*/




class Base
{
public:
	Base(int b)
		: _b(b)
	{}

	Base(const Base& b)
		: _b(b._b)
	{}

	Base& operator=(const Base& b)
	{
		if (this != &b)
		{
			_b = b._b;
		}

		return *this;
	}

	void SetBase(int b)
	{
		_b = b;
	}

protected:
	int _b;
};

class Derived : public Base
{
public:
	Derived(int b, int d)
		: Base(b)
		, _d(d)
	{}

	Derived(const Derived& d)
		: Base(d)
		, _d(d._d)
	{}

	Derived& operator=(const Derived& d)
	{
		if (this != &d)
		{
			// 给基类部分成员赋值
			Base::operator=(d); 

			// 给派生类新增加成员赋值
			//_d = d._d;//若只对来源于基类进行赋值，则不对派生类进行操作
		}

		return *this;
	}

	void SetDerived(int b, int d)
	{
		_b = b;
		_d = d;
	}

protected:
	int _d;
};


int main()
{
	Base b(10);
	Derived d1(10, 20);
	Derived d2(d1);

	Derived d3(30, 40);
	d2 = d3;
	return 0;
}

在继承体系中，基类与派生类的构造函数与析构函数的调用次序？？

	先调用派生类自己的构造函数，再跳转至基类构造函数，

		
class Base
{
public:
	Base(int b)
		: _b(b)
	{
		cout << "Base::Base(int)" << endl;
	}

	~Base()
	{
		cout << "Base::~Base()" << endl;
	}

protected:
	int _b;
};

class Derived : public Base
{
public:
	Derived(int b, int d)
		: Base(b)
		, _d(d)
	{
		cout << "Derived::Derived(int,int)" << endl;
	}

	~Derived()
	{
		cout << "Derived::~Derived()" << endl;
		// call Base::~Base();
	}

protected:
	int _d;
};


// 1. 运行结束打印结果
       /*
	      Base::Base(int)
		  Derived::Derived(int,int)
		  Derived::~Derived()
		  Base::~Base()
	   */
// 2. 构造和析构的调用次序
/*
打印次序（执行次序）：
		先调基类构造--->派生类构造--->派生类析构--->基类析构 （从打印结果来看）
	  // 有些情况下，千万不能过于相信自己的眼睛
	  // 打印次序并非调用次序

调用次序：
	  构造次序：
	    派生类构造函数() 
		   : 基类构造函数（）  // 打印Base::Base(int)

		{
				 打印Derived(int,int) //派生类构

		}

	  析构次序：
		派生类析构函数() 
		{
		     打印~Derived()// 释放派生类资源  
		  
		   // 编译器在派生类析构函数最后一条有效语句后插了一条汇编代码
		   call 基类析构函数;  //  打印Base::~Base()
		}
*/
void TestDerived()
{
	Derived d(10, 20);
}

int main()
{
	TestDerived();
	return 0;
}
5、继承与友元

友元不能被继承



class Base
{
	friend void Print();
public:
	Base(int b)
		: _b(b)
	{}

	int GetB()
	{
		return _b;
	}
protected:
	int _b;
};

class Derived : public Base
{
public:
	Derived(int b, int d)
		: Base(b)
		, _d(d)
	{}

protected:
	int _d;
};

void Print()
{
	Base b(10);
	cout << b.GetB() << endl;
	cout << b._b << endl;

	Derived d(10, 20);
	cout << d._d << endl;
}
6、继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成

员。无论派生出多少个子类，都只有一 个static成员实例 。

7、复杂的菱形继承
cout<<"下回讲解"<<endl;
抖立FLAG
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2007年4月计算机等级考试C++考试试卷参考答案及解析
芒果布丁00的博客
03-20 2260
2007年4月计算机等级考试C++考试试卷参考答案及解析 该试题网上流传的参考答案错漏比较多，本文已经对其进行修正，并添加了答案解析。 因本人水平有限，如果有错漏的地方还请多多指教！ 一、选择题（每小题2分，共70分） 下列各题A）、B）、C）、D）四个选项中，只有一个选项是正确的。请将正确选项涂写在答题卡相应位置上，答在试卷上不得分。 （1）下列叙述中正确的是。 A）算法的效率只与问
【C++】七、继承
海的早晨的博客
06-08 501
目录 一、继承的概念及意义 1.继承的概念 2.继承的定义 3.继承关系和访问限定符 4.继承基类成员访问方式的变化 二、.基类和派生类对象赋值转换 三、继承中的隐藏 四、派生类的默认成员函数 1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函 数，则必须在派生类构造函数的初始化列表阶段显示调用。 2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化 3. 派生类的operator=必须要调用基类的operator=完成基类.
错题整理2
pyd_pyd的博客
10-14 130
C++和进程方面的错题
C++继承
myscratch的博客
12-24 821
C++继承
类---继承
qq_40250321的博客
11-14 468
1. 基类和派生类 c++中的继承：从既有类（基类）产生新类（派生类） 1.1 派生类的生成步骤 吸收基类的成员 改造基类的成员 新增自己的成员 1.2 派生类的局限 数据成员可以完全吸收，但成员函数不能 不能被继承：构造、析构函数、基类重载的operator=/new/delete函数、友元关系 1.3 派生方式 派生方式 基类中访问权限 派生类访问权限 派生类对象访问权限 public public public 可以直接访问 protecte
派生类的构造函数的初始化列表问题,Widget::Widget(QWidget *parent) :QWidget(parent)
热门推荐
$firecat利白的代码足迹$
02-20 1万+
该如何理解下面段代码的第二行QWidget(parent)? Widget::Widget(QWidget *parent) : QWidget(parent),//???? ui(new Ui::Widget) { ui-&gt;setupUi(this); } 一、派生类不能在成员初始化列表中直接初始化基类的成员 初始化基类成员 构造函数是不可继承的。因此......
【C++】十七、继承
qq_43411555的博客
07-30 209
一、类和类的关系 二、继承基本概念 三、继承方式 四、同名函数的关系：重载，隐藏，覆盖 五、基类和派生类对象的相互引用
C++类继承示例
01-20
C++的子类与孙子类都实现了虚函数时，孙子类的实现会覆盖掉子类的实现。 　继承的主要的应用是把不同的类放到一个数组中，然后遍历调用同名函数。 　实例如下： #include #include #include using ...
C++多继承Demo
05-01
在C++编程语言中，多继承是一种特性，允许一个派生类从多个基类继承属性和行为。这个特性使得代码重用更为灵活，但同时也带来了潜在的问题，如菱形问题和二义性。本示例"**C++多继承Demo**"通过包含源代码文档...
c++课件第九章继承共29页.pdf.zip
10-29
以下是关于C++继承的详尽解析： 1. 继承的概念： 继承是OOP（面向对象编程）的关键特性，它允许一个类（子类或派生类）获取另一个类（基类或父类）的属性和方法。这种机制使得代码重用和类的层次结构得以实现，...
C++公有继承、保护继承和私有继承的区别
12-22
在C++中，继承是一种机制，允许一个类（派生类）从另一个类（基类）获取特性。这种机制使得代码重用和扩展变得更加容易。C++提供了三种不同的继承方式，每种方式对基类成员的访问权限有不同的规定，分别是公有继承...
C++.继承——虚继承
xiaoyu1381的博客
10-18 2052
C++.继承——虚继承
C++程序设计试题及答案解析（二）
MrLuo8的博客
05-01 7969
C++程序设计模拟试卷(二) 一、单项选择题 1. 静态成员函数没有（） A. 返回值 B. this指针 C. 指针参数 D. 返回类型 答案：B 解析：(P107)静态成员函数是普通的函数前加入static,它具有函数的所有的特征：返回类型、 形参，所以使用(P107)静态成员函数，指针可以作为形参，也具有返回值。静态成员是类具有的 属性，不是对象的特征，而this表示的是隐藏的对象的指针，因此静态成员函数没有this 指针 。静态成员函数当在类外定义时，要注意不能使用static
C++面向对象2
weixin_39187443的博客
02-18 132
虚基类
简历-求职简历-word-文件-简历模版免费分享-应届生-高颜值简历模版-个人简历模版-简约大气-大学生在校生-求职-实习
08-25
简历-求职简历-word-文件-简历模版免费分享-应届生-高颜值简历模版-个人简历模版-简约大气-大学生在校生-求职-实习 简历是展示个人经历、技能和能力的重要文档，以下是一个常见的简历格式和内容模板，供您参考： 简历格式： 头部信息：包括姓名、联系方式（电话号码、电子邮件等）、地址等个人基本信息。 求职目标（可选）：简短描述您的求职意向和目标。 教育背景：列出您的教育经历，包括学校名称、所学专业、就读时间等。 工作经验：按时间顺序列出您的工作经历，包括公司名称、职位、工作时间、工作职责和成就等。 技能和能力：列出您的专业技能、语言能力、计算机技能等与职位相关的能力。 实习经验/项目经验（可选）：如果您有相关实习或项目经验，可以列出相关信息。 获奖和荣誉（可选）：列出您在学术、工作或其他领域获得的奖项和荣誉。 自我评价（可选）：简要描述您的个人特点、能力和职业目标。 兴趣爱好（可选）：列出您的兴趣爱好，展示您的多样性和个人素质。 参考人（可选）：如果您有可提供推荐的人员，可以在简历中提供其联系信息。 简历内容模板： 姓名: 联系方式: 地址: 求职目标: （简短描述您的求职意
JAVA版基于netty的物联网高并发智能网关
08-25
JAVA版基于netty的物联网高并发智能网关
粮食波动率等相关农业数据（2011-2022）（全新整理）
08-25
1、资源内容地址：https://blog.csdn.net/2301_79696294/article/details/141441802 2、代码特点：今年全新，手工精心整理，放心引用，数据来自权威，相对于其他人的控制变量数据准确很多,适合写论文做实证用 ，不会出现数据造假问题 3、适用对象：大学生，本科生，研究生小白可用，容易上手！！！ 3、课程引用: 经济学，地理学，城市规划与城市研究，公共政策与管理，社会学，商业与管理 数据内容： 1.人均粮食产量 2.粮食总产量 3.粮食产量波动率（（当年粮食产量-历年粮食产量均值）/均值）：粮食生产受自然因素和市场等经济社会因素影响较大，常常表现出一定的波动。粮食产量波动率是衡量粮食生产稳定能力的重要指标之一。粮食产量波动率 Rt＝（Yt−Yt＇）／Yt＇，其中 Yt表示 t 年粮食总产量，Yt＇ 表示粮食产量 5 年移动平均值。 4.粮食播种面积 5.粮食单位面积产量 6.谷物/非谷物产量 7.秋收/夏收粮食产量 8.粮食进口数量 9.粮食进口金额 10.粮食出口金额 11.粮食外贸依存度（粮食进出口总额/农业
基于微信小程序高校寻物平台设计与实现.docx
08-25
基于微信小程序高校寻物平台设计与实现.docx
ant-design-3.20.3.zip
最新发布
08-25
ant-design，一套企业级 UI 设计语言和 React 组件库 提炼自企业级中后台产品的交互语言和视觉风格 开箱即用的高质量 React 组件
C++继承与派生详解
"继承与派生是C++中面向对象编程的重要概念，它允许我们创建新的类（派生类）基于已存在的类（基类），以实现代码的重用和扩展。继承使得派生类能够继承基类的属性和方法，同时可以添加新的特性或者覆盖原有的行为。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值