C++学习笔记——继承

最新推荐文章于 2024-07-24 13:36:39 发布
最新推荐文章于 2024-07-24 13:36:39 发布
阅读量192 收藏 1
点赞数
分类专栏： # C++入门学习系列 文章标签： 继承 多继承 菱形继承
来自Coolnaut的原创，欢迎在下方指出错误和评论，转载链接为：
本文链接：https://blog.csdn.net/Void_leng/article/details/90486247
版权

对于面向对象的C++来说，不能仅仅依靠参数类型来使用函数来实现代码的复用，应该也有使用对象来实现代码的复用

目录

 一、继承的初始

1、概念

2、定义

3、实例

二、基类和派生类对象赋值转换

三、继承中的作用域

四、派生类的默认成员函数

1、构造和析构

2、拷贝构造和运算符重载

五、友元与静态

1、友元关系不能继承

2、继承体系共享静态成员

六、菱形继承

1、多继承

2、菱形继承

3、问题

总结

 一、继承的初始

  • 1、概念

一说到继承，在现实生活中便可以想到继承家产，继承不仅仅是家产，还继承了父亲的姓，和父亲的一些特征。在c++里继承是面向对象程序设计里到代码复用的一种手段。当然继承是指类的继承。被继承的类称为基类，继承的类叫派生类。

  • 2、定义

1、定义格式：

2、继承方式：

3、继承间的访问限定

类成员/继承方式

public继承 protected继承 private继承
基类的public成员 派生类的public成员

派生类的protected成员

派生类的private成员

基类的protected成 员

派生类的protected成员

派生类的protected成员

派生类的private成员

基类的private成员在派生类中不可见在派生类中不可见在派生类中不可见

总结：

  1. public继承，父类成员是什么权限继承下来就是什么权限。
  2. protected继承，public成员变成保护成员。基类的保护成员在派生类可以访问。所以才说这是继承产生的权限符。
  3. private继承，都成为私有成员。
  4. 父类的私有成员在派生类中是不可见的，不可见是指看不见，但不是不存在。
  5. 由于后两种继承与继承的初衷有所违背，因为继承就是为了扩展，但是候两者成员只能在派生类使用，扩展性不强了。

  • 3、实例

class Person
{
public:
	Person()
		:name_("张三")
		,assess_("富有")
	{
		cout << "Person()" << endl;
	}
protected:
	string assess_;
private:
	string name_;
};
class Student : public Person
{
public:

private:
	int stunum_;//学号
};

上述代码student类继承了person类，会调用父类的构造方法来初始化来自父类的成员，当然由于name_是父类私有的，所以是不可见的，但是assess_是保护的，所以可见。

二、基类和派生类对象赋值转换

在内置类型中，我们可以这样，它们是可以进行隐式类型转换，但是会丢失精度。

int a = 1;
double b = 3.14;

a = b;

int c = 1;
double d = 3.14;

c + d;

在基类和派生类对象的赋值中也有转换。它们的转换是这样的。

这里有几个要注意的地方：

  1. 赋值的情况只能是基类的对象 / 基类的指针 / 基类的引用
  2. 只能派生类赋值给基类；因为派生类对于的成员会被切掉然后对基类进行赋值，派生类有基类的所有成员，但是基类没有派生类的，所以基类给派生类赋值可能造成，非法访问
  3. 基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的
class Person
{
public:
	Person()
		:name_("张三")
		,assess_("富有")
	{
		cout << "Person()" << endl;
	}
	void setName(const string& name)
	{
		name_ = name;
	}
protected:
	string assess_;
private:
	string name_;
};

class Student : public Person
{
public:
	Student()
		:stunum_("123456")
	{
		assess_ = "富二代";
		cout << "Student()" << endl;
	}
	void Myname(const string& name)
	{
		setName(name);
	}
private:
	string stunum_;//学号
};

对于上面的代码做以下实验：

三、继承中的作用域

之所以说作用域呢，是因为这里又会有一个新的词出现叫——隐藏。在继承中基类和派生类都有独立的作用域。 如果子类和父类中有同名（名字相同）成员，子类成员将屏蔽父类对同名成员的直接访问，子类只能访问自己的函数，如果是子类对基类进行赋值，父类也只能调用自己的函数。这种情况就叫隐藏，或者说是重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）。但这不是重载，因为不在同意作用域内。所以在实际中在继承中最好不要定义同名的成员

class Child;
class Father
{
public:
	Father(const string& name = "张三", int age = 10)
		:name_(name)
		, age_(age)
	{
		cout << "Father()" << endl;
	}
	void Func(int tmp)//函数隐藏
	{
		cout << tmp << endl;
	}
	~Father()
	{}
private:
	string name_;
	int age_;
};

class Child : public Father
{
public:
	Child(const string& sex = "男", int grade = 90)
		:sex_(sex)
		, grade_(grade)
	{
		cout << "Child()" << endl;
	}
	void Func()
	{
		cout << "NULL" << endl;
	}
	~Child()
	{}
private:
	string sex_;
	int grade_;
};

四、派生类的默认成员函数

在前面接触c++的类和对象时，已经学习来了，类的六大默认成员函数，来自继承之后的派生类，会继承基类的成员，所以它的成员函数又会是怎样的？

1、构造和析构

1）派生类对象初始化先调用基类构造始化基类的那一部分成员，如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用，再调派生类构造，，初始化自己的成员。

2） 派生类对象析构清理先调用派生类析构再调基类的析构。

class Father
{
public:
	Father(const string& name = "张三", int age = 10)
		:name_(name)
		, age_(age)
	{
		cout << "Father()" << endl;
	}
	void Func(int tmp)//函数隐藏
	{
		cout << tmp << endl;
	}
	~Father()
	{
		cout << "~Father()" << endl;
	}
private:
	string name_;
	int age_;
};

class Child : public Father
{
public:
	Child(const string& sex = "男", int grade = 90)
		:sex_(sex)
		, grade_(grade)
	{
		cout << "Child()" << endl;
	}
	void Func()
	{
		cout << "NULL" << endl;
	}
	~Child()
	{
		cout << "~Child()" << endl;
	}
private:
	string sex_;
	int grade_;
};

void test3()
{
	Child c1;
}
int main()
{
	test3();
	system("pause");
	return 0;
}

  • 2、拷贝构造和运算符重载

1）派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

2）派生类的operator=必须要调用基类的operator=完成基类的复制。

class Father
{
public:
	Father(const string& name = "张三", int age = 10)
		:name_(name)
		, age_(age)
	{
		cout << "Father()" << endl;
	}
	Father(const Father& f)
		:name_(f.name_)
		,age_(f.age_)
	{
		cout << "Father(&)" << endl;
	}
	Father& operator=(const Father& f)
	{
		if (this != &f)
		{
			this->name_ = f.name_;
			this->age_ = f.age_;
		}
		cout << "Foperator=" << endl;
		return *this;
	}
	~Father()
	{
		cout << "~Father()" << endl;
	}
private:
	string name_;
	int age_;
};

class Child : public Father
{
public:
	Child(const string& sex = "男", int grade = 90)
		:sex_(sex)
		, grade_(grade)
	{
		cout << "Child()" << endl;
	}
	Child(const Child& c)
		:Father::Father(c)
		,sex_(c.sex_)
		, grade_(c.grade_)
	{
		cout << "Child(&)" << endl;
	}
	Child& operator=(const Child& c)
	{
		if (this != &c)
		{
			Father::operator=(c);
			this->sex_ =c.sex_;
			this->grade_ =c.grade_;
		}
		cout << "Coperator=" << endl;
		return *this;
	}

	~Child()
	{
		cout << "~Child()" << endl;
	}
private:
	string sex_;
	int grade_;
};

五、友元与静态

  • 1、友元关系不能继承

就是说基类友元不能访问子类私有和保护成员，因为爸爸的朋友不是孩子的朋友。

class A
{
	friend void Display(const A& a);
public:
	A(const int& a = int())
		:a_(a)
	{}
private:
	int a_;
};
void Display(const A& a)
{
	cout << a.a_ << endl;
}
class B : public A
{
public:
	B(const int& b = int())
		:A::A()
		,b_(b)
	{}
private:
	int b_;
};

  • 2、继承体系共享静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一 个static成员实例

class A
{
public:
	A(const int& a = int())
		:a_(a)
	{}
	static void Print(const A& a);
private:
	int a_;
};
void A::Print(const A& a)
{
	cout << a.a_ << endl;
}

class B : public A
{
public:
	B(const int& b = int())
		:A::A()
		,b_(b)
	{}
private:
	int b_;
};
class C : public A
{
public:
	C(const int& c = int())
		:A::A()
		, c_(c)
	{}
private:
	int c_;
};

六、菱形继承

  • 1、多继承

在c++的语法里，不仅仅有单继承还有多继承，多继承就像是多个身份一样，你可以是班长，也可以同时是学委；可以是老师，也会是学生，老师也有老师。

  • 2、菱形继承

菱形继承是多继承和单继承组合形成的

  • 3、问题

我们先从对象模型上来看

class Person
{
public:
	Person()
		:name_("张三")
		,assess_("富有")
	{
		cout << "Person()" << endl;
	}
protected:
	string assess_;
private:
	string name_;
};

class Student : public Person
{
public:
	Student(const string str = "123456" )
		:stunum_(str)
	{
		assess_ = "富二代";
		cout << "Student()" << endl;
	}
private:
	string stunum_;//学号
};
class Teacher : public Person
{
public:
	Teacher(const string str = "123456")
		:edunum_(str)
	{
		assess_ = "富大代";
		cout << "Teacher()" << endl;
	}
private:
	string edunum_;
};

class Self : public Student, public Teacher
{
public:
	Self()
	{}
};

从上面的监视中可以看见多继承的对象模型是这个样子的，

看到红色的圈子中，self类的对象是富二代还是富大代？这就带来菱形继承有数据冗余和二义性的问题。为了解决菱形继承的问题，大佬便发明了虚拟继承，什么是虚拟继承。就是在相同的基类前加virtual关键字。

class Student : virtual public Person
{
public:
	Student(const string str = "123456" )
		:stunum_(str)
	{
		assess_ = "富二代";
		cout << "Student()" << endl;
	}
private:
	string stunum_;//学号
};
class Teacher : virtual public Person
{
public:
	Teacher(const string str = "123456")
		:edunum_(str)
	{
		assess_ = "富大代";
		cout << "Teacher()" << endl;
	}
private:
	string edunum_;
};

具体是怎么回事，在后面的多态在进行介绍，毕竟，这篇博客有点长了【哈哈】。

总结

在继承这点，可以说在c++这里是个不足啊。首先是三个访问限定符，晕头转向，还妨碍与继承的初衷（扩展性）相悖。再者就是多继承了，有多继承就带来了菱形继承，有了菱形继承带来了虚拟继承，虚拟继承有带来了复杂的底层结构。补了一个坑，又有一个坑。有点拆东墙补西墙的感觉。

C++学习笔记——继承和组合
06-06
这就是继承的一个重要特性——多态性。 #### 3. 继承的访问控制 继承时可以通过不同的访问限定符来控制父类成员在子类中的可见性。例如，如果使用`public`继承，则父类的公有成员在子类中仍然是公有的；如果使用`...
cpp代码-c++学习笔记——类与对象
07-16
本学习笔记将深入探讨这两个概念以及如何在实际编程中应用它们。 首先，类是C++中的一种用户自定义数据类型，它允许我们将相关的数据和函数封装在一起。类可以看作是一个蓝图或模板，定义了具有特定属性（数据成员...
C++ 学习笔记----继承篇
weixin_30782293的博客
11-18 79
（一）基本概念和语法 1、术语：父类（基类）、子类（派生类）、单继承、多继承； 2、一个继承实例：（默认继承方式是private） 1 //类BC继承自DC 2 class BC : public DC { 3 //........ 4 }; 3、继承机制下的私有成员： 　　基类的私有成员可以有派生类继承，但对派生类是不可见的； 4、改变...
C++学习笔记——继承和动态内存分配
华数云图小分队的博客
01-11 1098
C++学习笔记——继承和动态内存分配——继承和动态内存分配是C++中两个重要的概念。
C++学习笔记——类继承
华数云图小分队的博客
01-11 974
通过继承和多态性的机制，基类和派生类之间建立了一种强大的关系，使得面向对象程序具有更好的可维护性和可扩展性。通过使用基类指针或引用来引用派生类的对象，可以以相同的方式调用基类的成员函数，从而实现代码的灵活性和可扩展性。因此，在分析成本和评估绩效时，要以客户为中心，关注他们的需求和反馈，并根据客户的需求来制定产品和服务的设计、生产和销售策略。强调活动的重要性：企业的成本和绩效不仅取决于产品和服务本身，还受到生产和销售过程中的各种活动的影响。关键字，派生类将继承基类的保护成员，并将其作为自己的保护成员。
C++学习笔记 —— 继承与多重继承
Charles Ren's Tech Blog
12-13 2227
继承同名变量解析 如果子类只是继承父类的变量，则在子类中该变量其实只有一个，他的名字可以叫 d.A::n d.B::n 或 d.n，他们三个都是一个人 class A { public: int n; }; class B: public A {}; class D: public B {}; int main() { D d; d.A::n = 10; d.B::n = 20; d.n = 30; cout<<
C++学习笔记——继承与多态
weixin_45121946的博客
06-18 1068
继承与多态都是C++中很重要的两个概念，也是相比起C语言的优势所在，下面就来总结一下C++中继承与多态的概念以及简单用法！ 一.继承 1.1 什么是继承？ 面向对象思想是一种跟家符合人类思维的思想，一开始我还不怎么理解这句话，但是随着对C++以及面向对象思想的学习，我越发感觉到这句话的意义所在。 因为C++中的一大特点，封装的存在，将一类对象的共同特点，共有的成员和方法封装成类，但是，不可能每一类对象都要从头进行封装，就像游戏给一个英雄添加了一项新技能技能，总不能重头在创建一个新的英雄类吧，而且，在升级系统
C++学习笔记——模板
最新发布
不想随波逐流的大学生一枚，我们每个人都在努力奔跑
07-24 1154
总结：类模板中的成员函数并不是一开始就创建的，在调用时才去创建。函数模板的作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个。总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板。总结：主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp。总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别。1、如果函数模板和普通函数都可以实现，优先调用普通函数。总结：类模板中成员函数类外实现时，需要加上模板参数列表。
C++学习笔记——继承与多态（一）：多态的实现
weixin_42923076的博客
01-18 171
C++学习笔记——继承与多态（一）：多态的实现 明天预告：多态的原理
C++学习笔记——继承与多态（三）：虚函数
weixin_42923076的博客
01-20 151
C++学习笔记——继承与多态（三）：虚函数 明天预告：虚继承
C++进阶个人学习笔记——继承（1）
jinyx186的博客
04-19 1764
C++继承的初阶学习
C++整理笔记word版——01 C++学习笔记
12-05
C++是一种强大的面向对象编程语言，它源自C语言并扩展了其...学习这些概念是成为C++程序员的第一步。在实际编程中，还需要理解类、对象、继承、多态等面向对象编程的概念，以及函数、模板、文件操作等更高级的主题。
C++语言基础——vector
Coulnaut的博客
04-19 1829
vector是表示可变大小数组的序列容器。vector的学习按照数据结构的顺序表。 目录 ---- vector认识 ----构造函数 ----vector的容量增长 ----vector的增删查改 ----vector的运用 ----vector的模拟实现 ----vector的优缺点 vector 就像数组，一个vector对象，就必须是相同类型的元素。当我...
C++学习笔记——右值引用与lambda表达式
Coulnaut的博客
08-17 1239
相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率。这里介绍两个特性。 目录 右值引用 右值和左值 左值引用与右值...
C++语言基础——list
Coulnaut的博客
04-27 1167
对于list，它也是一个容器，但list的底层就是双向链表结构，list我们按照前面学习的带头节点双向循环链表。 博文目录 list 构造函数 list的容量 list的增删 list的迭代器 list的模拟实现 vector和list的对比 list 对于list有三个成员变量，prev指针：指向前一个结点，即前驱结点；next指针：指向后一个结点，即后继...
C++语言基础——IO操作
Coulnaut的博客
05-18 951
在学习C语言的时候，就已经接触到输入输出操作。但是对于C++面向对象的特性，输入输出就相对简单和安全多了。 目录 引言 流 IO流 认识 进阶 控制符 文件IO 文件的打开与关闭 文件的读和写 引言 以前在学习c语言的时候，是用printf和scanf进行输出和输人的方法。C++与C兼容的，所以也保留了用printf和scanf进行输出和输人的方法，以便使过去所编写的...
C++语言基础——stack和queue
Coulnaut的博客
05-16 810
学习完容器，来看看容器适配器。容器适配器也是STL的组成部分。 目录 deque 概念 迭代器 特点 总结 容器适配器 stack 概念 接口 应用 实现 queue 概念 接口 应用 实现 priority_queue 概念 接口 运用 细节 deque 概念 在说容器适配器之前，先来说下双端队列，双端队列也是一个容器。名字是双端队...
C++学习笔记——关联式容器（下）
Coulnaut的博客
08-18 646
前面的树形结构的关联式容器介绍完，下面要说的是哈希结构的关联式容器。 文章目录1. unordered系列2. 哈希2.1 概念2.2 哈希冲突2.3 哈希函数2.3.1 除留余数法2.3.2 直接定址法2.4 哈希冲突的解决2.4.1闭散列2.4.1.1 线性探测2.4.1.2 二次探测2.4.2 开散列2.4.2.1 哈希桶2.4.2.2 具体实现 1. unordered系列 看到uno...
C++学习笔记：带默认参数的函数解析
"C++学习笔记——带默认参数的函数" 在C++编程中，函数是实现特定功能的代码块，可以被多次调用。本节我们将探讨带默认参数的函数这一特性，这是C++相对于C的一个重要区别。 在C语言中，函数的形参没有默认值，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值