【C++】继承

最新推荐文章于 2024-04-22 13:19:15 发布
最新推荐文章于 2024-04-22 13:19:15 发布
阅读量882 收藏 2
点赞数 1
分类专栏： C++ 文章标签： c++ java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63249832/article/details/130460550
版权

文章目录

1. 继承的概念及定义

1. 继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用

举个例子，假设有这样一个场景，我们需要做一个面向整个学校里所有人的系统，那么系统的使用者就有很多身份，比如说学生、老师等，我们会发现，可能很多变量的定义是重复的，比如姓名，年龄等，所以可以抽象出一个类表示人的特征

image-20230501154631022

2. 继承的定义

那么我们如何用代码的方式表现出继承呢？

class Person
{
public:
	void print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "zht";//姓名
	int _age = 18;//年龄
};
class student : public Person
{
protected:
	int _stuid;//学号
	string _major;//专业
};
class teacher : public Person
{
protected:
	int _jobid;//工号
};

image-20230501155440231

那么继承了之后，子类是什么样子的呢？

image-20230501160139430

image-20230501160245975

可以看到，父类的成员子类在子类中都会存在，而且子类能够调用父类中的成员函数。那么这个调用的规则是怎么样的？是不是父类所有的成员子类都能够调用？

3. 继承关系和访问限定符

在博文类和对象(上)中我们了解到在定义类的时候，访问限定符有public,protected,private三种，现在继承关系也是这三种情况。在之前的学习中，我们只关注到public和private两种访问限定符，而且对于之前，我们说private和protected没有区别，那么private和protected的区别在哪里呢？区别就在继承上。

基类成员继承后在派生类中的访问权限

类成员/继承方式public继承protected继承private继承
基类的public成员相当于派生类的public成员相当于派生类的protected成员相当于派生类的private成员
基类中的protected成员相当于派生类中的protected成员相当于派生类中国的protected成员相当于派生类中的private成员
基类中的private成员在派生类中不可见在派生类中不可见在派生类中不可见

上面那个表看起来太复杂了，而且很多其实都用不上，所以，我们来总结一下其中重点

  1. 基类中的private成员无论采用何种继承方式，在派生类中始终是不可见的。

    注意：这里的不可见代表的是不能访问类成员，而不是不被继承下来。基类的所有成员都是被继承下来的，但是语法上限制了访问操作，就像在类外不能访问private和protected修饰的成员一样

  2. 如果想要使基类中的成员在派生类中能够被访问，但是在类外不能被访问，就需要使用protected修饰，这就是protected出现的原因

  3. 基类成员在派生类中的访问权限可以使用一个公式推导：前提：public > protected > private,最终的访问权限为min(基类成员的访问限定符，继承方式)。

  4. 在继承的时候，可以不显示写出继承方式。使用class修饰派生类的时候，默认的继承方式为private，使用struct修饰派生类的时候，默认继承方式为public。

  5. 在实际使用中，一般的继承方式都是public。不提倡使用protected/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强

2. 基类和派生类对象赋值转换

我们知道，在C++中，如果想将一个int类型的数据赋值给一个double类型，其中的过程是会产生一个int类型的临时变量，中间会经历隐式类型转换这个过程。但是当把一个派生类对象赋值给一个基类对象的时候，就不会出现隐式类型转换，可以直接赋值。这里有个形象的说法叫做切片或者切割。

image-20230501182721525

我们看下面一段代码

class Person
{
public:
	void print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "zht";//姓名
	int _age = 18;//年龄
};
class student : public Person
{
public:
	int _stuid = 1111111;//学号
	string _major = "CST";//专业
};
void Test2()
{
	student s;
	//1.子类对象赋值给父类：对象/指针/引用
	Person p = s;
	Person* pp = &s;
	Person& rp = s;
	//2.基类对象不能赋值给派生类对象
	s = p;
	//3.基类的指针可以通过强制类型转换赋值给派生类的指针
	pp = &s;
	student* ps1 = (student*)pp; // 这种情况转换时可以的。
	ps1->_stuid = 10;
	pp = &p;
	student* ps2 = (student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
	ps2->_stuid = 10;
}
  • 派生类对象可以向上赋值给基类对象/基类指针/基类引用
  • 基类对象不能向下赋值给派生类
  • 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换

3. 继承中的作用域

  • 在继承体系中，基类和派生类都有独立的作用域
  • 如果出现派生类和基类中有同名成员的情况，派生类成员将屏蔽对基类成员的直接访问，这种情况叫做隐藏(重定义)。如果需要访问基类成员，可以采用基类::基类成员的方式显示访问。
  • 对于成员函数，只要函数名相同就构成隐藏
  • 在实际应用中，继承体系里最好不要定义同名成员
class Person
{
public:
	void print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "zht";//姓名
	int _age = 18;//年龄
	int _num = 22222;
};
class student : public Person
{
public:
	int _stuid = 1111111;//学号
	string _major = "CST";//专业
	int _num = 666;
};
void Test3()
{
	student s;
	cout << s._num << endl;
}

image-20230501190043445

经典笔试题

class A
{
public:
	void fun()
	{
		cout << "A::fun()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		cout << "B::fun(int i)" << i << endl;
	}
};
void Test4()
{
	B b;
	b.fun();
}

❓上述两个fun函数是什么关系，重载？重写？隐藏？编译报错？

✅看到两个函数名相同，参数不同，很多人都会直接脱口而出“函数重载”，但是不是这样的，函数重载有一个前提就是函数在统一作用域，这里基类和派生类不是同一作用域。所以这里两个fun构成的关系是隐藏，所以Test4中调用的函数是B类中的函数，所以这里会编译报错，因为传入的参数不够。

4.子类(派生类)的默认成员函数

在类和对象(中)我们了解到类中有6个默认成员函数，默认的意思是我们不写，编译器会自动生成。那么在派生类中，这六个默认成员函数的特性又有什么变化呢？

  1. 派生类的构造函数对于基类部分的成员，必须调用基类的构造函数初始化，如果基类没有默认构造函数，则必须在派生类构造函数的初始化列表阶段显示调用
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造函数完成基类的拷贝初始化
  3. 派生类的operator=必须调用基类的operator=完成基类的复制
  4. 派生类的析构函数不需要显示调用基类的析构函数，由编译器在析构派生类成员之前调用基类的析构函数，从而达到先析构基类成员的目的
  5. 对于派生类对象，构造时先初始化基类部分，析构时，先析构派生类部分。
  6. 由于一些原因，编译器对于继承体系的析构函数都会处理成destruct，所以，在不加virtual的情况下，派生类和基类的析构函数构成隐藏关系。

总结起来就是，在派生类中，所有需要对基类成员进行操作的事情都交给基类的成员函数处理，至于派生类中有动态开辟的资源的情况，当然要我们手动的写。

image-20230501192320302

class Person
{
public:
	Person(const char* name = "zht")
		:_name(name)
	{
		cout << "Person(const char* name)" << endl;
	}
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name;
};
class student : public Person
{
public:
	student(const char* name = "zht", int num = 11111)
		: Person(name)
		, _num(num)
	{
		cout << "student()" << endl;
	}
	student(const student& s)
		: Person(s)
		, _num(s._num)
	{
		cout << "Student(const student& s)" << endl;
	}
	student& operator = (const student& s)
	{
		cout << "student& operator= (const student& s)" << endl;
		if (this != &s)
		{
			Person::operator =(s);
			_num = s._num;
		}
		return *this;
	}
	~student()
	{
		cout << "~student()" << endl;
	}
protected:
	int _num; //学号
};
void Test5()
{
	cout << "测试构造和析构" << endl;
	student s;
	cout << "测试拷贝构造" << endl;
	student s1(s);
}

image-20230501210703779

5. 继承与友元

对于友元关系，类继承的时候是不能被继承的，也就是说，基类友元不能访问派生类的私有和保护成员，如果需要访问的话，就需要在派生类中也规定友元。

class Student;
class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};
class Student : public Person
{
protected:
	int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	cout << s._stuNum << endl;
}
void Test6()
{
	Person p;
	Student s;
	Display(p, s);
}

image-20230501212022924

解决方案：

image-20230501212259681

6. 继承与静态成员

在基类中定义了一个静态成员，则此成员在继承体系中是共享的，只有一个这样的成员

class Person
{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
string _seminarCourse; // 研究科目
};
void Test7()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << "人数:" << Person::_count << endl;
	Student::_count = 0;
	cout << "人数:" << Person::_count << endl;
}

image-20230501213945520

7. 菱形继承与菱形虚拟继承

1. 继承的种类

在C++继承的设计中，为了满足各种实际情况，设计了单继承和多继承

单继承：一个子类只有一个直接父类

多继承：一个子类有超过一个父类

image-20230501231824602

在上述情况的前提下，会出现一种可能的继承结构：菱形继承

image-20230501232201453

在菱形继承中就会出现数据冗余和二义性的问题。对于上述的例子，在Assistant对象中Person的成员会有两份，造成了数据冗余，如果在Assistant对象中访问Person中的成员就会出现二义性，不知道访问Student基类还是Teacher基类中的Person成员。虽然我们可以使用显示指定访问类的方法解决二义性的问题，但是对于数据冗余还是没有办法解决，所以这里引入了虚拟继承的方式

2. 虚拟继承

对于上面的继承关系，在Student和Teacher的继承中使用Person虚拟继承，就可以解决问题，但是这里注意虚拟继承不要在其他地方使用

class Person
{
public:
	string _name; // 姓名
};
//class Student : public Person
class Student : virtual public Person//虚拟继承
{
protected:
	int _num; //学号
};
//class Teacher : public Person
class Teacher : virtual public Person//虚拟继承
{
protected:
	int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

虚拟继承解决数据冗余和二义性的原理

首先，这里我们给出一个简化的菱形继承的示例

class A
{
public:
	int _a;
};
// class B : public A
class B : virtual public A
{
public:
	int _b;
};
// class C : public A
class C : virtual public A
{
public:
	int _c;
};
class D : public B, public C
{
public:
	int _d;
};
void Test8()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
}

如果不适用虚拟继承的方式，那么对象d的内容是这样的

image-20230501234539889

当使用虚拟继承之后,d对象的内容是这样的：

image-20230502000851488

可以看到，这里是把公共的_a放到了最下面，这个_a同时属于B和C，那么他们怎么找到_a呢？这里是通过B和C的两个指针，指向的一张虚基表，着两个指针叫做虚基表指针，虚基表指针中存放的是偏移量，通过偏移量就可以找到下面的_a。

对上述的结构，有下面一张图来辅助理解：

image-20230502002155704

8. 继承与组合

继承的本质就是类的复用，类的复用除了继承之外，还有一种复用方式叫组合，二者最大的区别就是访问方式不同

  • public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
  • 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象
class M
{

};
class N : public M//public继承
{

};
class X//组合
{
public:
	M mm;
};

继承实际上是一种白箱复用，组合是一种黑箱复用，继承中派生类对于基类的内部细节大多可见，一定程度上破坏了封装，而组合就不会关心内部实现，只是通过提供的接口来使用，高内聚，低耦合，有很好的封装性。当然，由于组合使用的特性，对被组合类的接口要求就相对高一点。

综上，这里有一个原则：优先使用对象组合，而不是继承。

9.总结

  1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。

  2. 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。

  3. 在继承和组合中，优先使用组合优先使用对象组合，而不是类继承。

凌云志.
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++继承
IT_iverson的博客
09-08 556
一，继承相关概念 二.派生类的定义 代码举例如下： class Parent//基类 { private: int a; public: void print() { cout << "a=" << a << endl; } protected: }; class Child :public Parent//派生类，这里的public 可以也可以是private或
C++ Parent和Child继承分析
基础研究
02-26 1588
继续分析1.继承实例分析2.class Parent 1.继承实例分析 #include <iostream> #include <stdio.h> #include <unistd.h> using namespace std; class Parent { public: char data[20]; void Function1(); virtual void Function2(); // 这里声明Function2是虚函数
C++静态变量
最新发布
人无远虑，必有近忧
04-22 1597
C语言中与“静态”相关的词包括，静态全局变量，静态局部变量和静态函数，关键词是static。C语言中的变量从作用域分，可以分为全局变量和局部变量；从存储方式分，可以分为静态存储方式和动态存储方式。
（C++）多态
weixin_53812805的博客
05-25 211
1、问题的引出 基类的指针指向派生类对象，在访问函数（基类与派生类的同名函数）时，只能调用基类的函数。 如何才能通过基类指针调用派生类函数？ #include <iostream> using namespace std; class Parent { public: void show() { cout<<"this is Parent"<<endl; } }; class Chil...
C++智能指针
weixin_43591948的博客
06-05 318
auto_ptr 由于auto_ptr被销毁时会自动删除它所之物，所以一定要注意别让多个auto_ptr指向同一个对象。如果真的是那样，对象会被删除一次以上，而那会是你的程序搭上“未定义行为”的快速列车上，为了预防auto_ptrs，有一个不同寻常的性质：若通过copy构造函数或copy assignment操作符复制它们，它们会变成null，从而复制所得的指针将取得资源的唯一拥有权 这是一个诡异的复制行为，附加上其底层条件：“受auto_ptr管理的资源必须绝对没有一个以上的auto_ptr同时指向它”，
深入C++虚函数表
oorik的博客
08-02 544
多态性是面向程序设计的关键技术之一。若程序设计语言不支持多态性，不能称为面向对象的语言。多态性是考虑在不同层次的类中，以及在同一类中，同名的成员的关系问题。说白了就是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。多态的分类多态又分为编译时的多态性(静态的多态性)，函数重载，运算符的重载都属于编译时的多态以类的虚成员函数为基础的运行时的多态virtual返回类型函数名（参数表）............
C++继承介绍
09-05
总结来说，C++继承是实现代码复用和创建类层次结构的重要手段。通过选择适当的继承类型、访问修饰符和虚函数，开发者可以构建灵活且强大的类体系，同时确保类型安全和多态性。理解和熟练运用这些概念对于编写高效、...
c++继承分类
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许我们创建新的类，这些新类可以扩展已存在的类的功能。在这个“c++继承分类”主题中，我们将深入探讨C++中的继承机制，以及如何在Qt环境中利用这一特性进行开发...
C++ 继承详解及实例代码
12-31
C++继承可以是单一继承或多重继承，每一个继承连接可以是public,protected,private也可以是virtual或non-virtual。然后是各个成员函数选项可以是virtual或non-virtual或pure virtual。本文仅仅作出一些关键点的验证...
c++继承的视频
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许一个类（子类或派生类）从另一个类（基类或父类）继承特性，从而实现代码的重用和扩展。在Qt框架中，C++的继承机制同样被广泛应用，以构建丰富的用户界面和...
c++继承描述
01-05
c++继承描述
c++关键字详解
11-14
C++关键字
12. C++中的继承
zhubao124的博客
11-16 301
一、继承的概念 1. 面向对象中的继承指类之间的父子关系； 2. 子类拥有父类的所有成员变量和成员函数； 3. 子类就是一种特殊的父类； 4. 子类对象可以当作父类对象使用； 5. 子类可以拥有父类没有的方法和属性； #include <cstdlib> #include <iostream> using na...
C/C++中静态变量
Blunt_Du的博客
01-10 1万+
C/C++中的静态变量1. 静态全局变量2.静态局部变量3. 静态函数4.类内静态成员变量5. 类内静态局部变量6.类内静态函数 C语言中与“静态”相关的词包括，静态全局变量，静态局部变量和静态函数，关键词是static。C语言中的变量从作用域分，可以分为全局变量和局部变量；从存储方式分，可以分为静态存储方式和动态存储方式。 需要区分的概念是，全局变量是存储在静态存储区的，所谓的静态存储区是一个进程所分配内存的.bss和.data段，但全局变量不是并不是静态变量。 1. 静态全局变量 下面代码中的a属于全局
关于QT/C++中explicit关键字和构造函数的*parent参数的简单说明
fengel_cs的专栏
03-04 2427
一、explicit关键字 1.   explicit是C++中的关键字，不是C语言中的，英文直译是“明确的”、“显式的”意思。 2. 出现这个关键字的原因，是在C++中有这样规定的基础上： 当定义了只有一个参数的构造函数时，同时也定义了一种隐式的类型转换。作用主要是用来修饰类的构造函数，表明该构造函数是显式的，禁止单参数构造函数的隐式转换。 3. 使用QT Creator默认生成代
C++继承学习过程
domoNaruto的博客
10-21 177
1.继承的三种方式 class Parent { public: int p_a; Parent() { p_a = 2; p_b = 5; p_c = 3; } private: int p_b; protected: int p_c; }; // 公有继承 class Child1:public Parent { public: voi...
C++学习——父类指针和子类指针的步长问题
学习笔记
11-09 1492
C++中父类指针可以指向子类对象，很多时候这的确提供了方便之门。担当遇到对象数组时，就要慎重考虑了。指针运算是按指针类型的长度进行计算的，对于子类对象数组，当使用父类指针指向子类对象时，指针的步长依然是父类对象所占的长度，指针移动后，所指的位置不一定就是下一个子类对象数组元素的起始地址。#include <iostream> using namespace std;class Parent {
c++继承(子类调用父类函数、全局函数)
热门推荐
qq_38611124的博客
12-21 1万+
#include #include using namespace std;   //父类 class Parent { public:       Parent(){};       void SetX(int x){m_x = x;};       void SetY(int y){m_y = y;};       ~Parent(){}; Private:
C++ 树-双亲表示法、孩子表示法、双亲孩子表示法
nightwizard2030的博客
04-08 5853
#include using namespace std; template struct Node{ T _data; int parent; }; template struct Tree{ Node array[100]; int count; }; template void addNode(T data,int parent,Tree& tree){ tree.array[tr
c++ 继承java类
01-12
C++可以继承Java类，但是需要注意一些细节和差异。在C++中，可以使用关键字`class`来定义一个类，并使用关键字`public`来指定继承关系。下面是一个示例： ```cpp class JavaClass { public: void javaMethod() { // Java类的方法实现 } }; class CppClass : public JavaClass { public: void cppMethod() { // C++类的方法实现 } }; ``` 在上面的示例中，`CppClass`继承了`JavaClass`，并且可以访问`JavaClass`中的公共成员函数`javaMethod()`。此外，`CppClass`还可以定义自己的成员函数`cppMethod()`。 需要注意的是，C++和Java在继承方面存在一些差异。其中一个主要的差异是C++支持多继承，而Java不支持。多继承是指一个类可以从多个父类继承属性和方法。这在某些情况下可以提供更大的灵活性，但也容易导致代码复杂性增加和潜在的冲突问题。 另一个差异是C++的继承关系可以是公有的、私有的或受保护的，而Java的继承关系始终是公有的。公有继承意味着派生类可以访问基类的公共成员，私有继承意味着派生类无法访问基类的成员，受保护继承意味着派生类可以访问基类的受保护成员。 总结起来，C++可以继承Java类，但需要注意多继承和访问权限的差异。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

凌云志.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值