【浅尝C++】继承机制=＞虚基表/菱形虚继承/继承的概念、定义/基类与派生类对象赋值转换/派生类的默认成员函数等详解

2024-04-06 13:36
文章标签 c++ 函数 详解 定义 概念 对象 转换 默认 继承 机制 成员 基类 赋值 菱形 派生类 浅尝 虚基表

本文主要是介绍【浅尝C++】继承机制=＞虚基表/菱形虚继承/继承的概念、定义/基类与派生类对象赋值转换/派生类的默认成员函数等详解，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

在这里插入图片描述

🏠专栏介绍：浅尝C++专栏是用于记录C++语法基础、STL及内存剖析等。
🎯每日格言：每日努力一点点，技术变化看得见。

文章目录

  • 继承的概念及定义
    • 继承的概念
    • 继承的定义
      • 定义格式
      • 继承关系与访问限定符
  • 基类和派生类对象赋值转换
  • 继承中的作用域
  • 派生类的默认成员函数
  • 继承与友元
  • 继承与静态成员
  • 复杂的菱形继承及菱形虚拟继承

继承的概念及定义

继承的概念

我们生活中也有继承的例子，例如：小明继承了孙老师傅做拉面的手艺。继承就是一种延续、复用的方式。C++为了提高代码的可复用性，引入了继承机制，概念如下↓↓↓

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

继承的定义

定义格式

下图演示的继承的格式，其中Person是父类，也称作基类；Student是子类，也称作派生类。
在这里插入图片描述

下面给出代码示例（下面代码中，Student类继承父类Person）↓↓↓

#include <iostream>
using namespace std;class Person
{
public:void Show(){cout <<  _name << " " << _age << endl;}
protected:string _name = "jammingpro";	//姓名int _age = 18;					//年龄
};class Student : public Person
{
private:int _stuId;
};int main()
{Person p;Student s;p.Show();s.Show();return 0;
}

在这里插入图片描述
上面代码中，Student继承父类Person的成员（成员函数+成员变量）后，这些成员都变成了子类的一部分。这里的Student复用了Person的成员。通过监视窗口可以看到，Student中也有自己的_name、_age成员变量。
在这里插入图片描述

继承关系与访问限定符

在C++的继承机制中，包含3种继承方式及3种类访问限定符（如下图所示），下面将分别介绍它们。
在这里插入图片描述

我们在学习类和对象时，就已经接触过访问限定符。其中public成员可以在类外访问，而protected与private成员不能在类外访问。但这里的protected和private在继承时是有区别的：
●如果父类愿意让自己的成员被外界访问并愿意让子类继承，则定义为public的；
●如果父类希望自己的成员不被外界访问而愿意让子类继承，则需要定义为protected；
●如果父类不希望自己的成员被外界访问、被继承，则需要定义为private的。

在这里插入图片描述

父类中的访问限定符表示父类愿不愿意让子类继承，而继承方式则可以让子类缩小父类成员的访问权限，但不能放大父类成员的访问权限。

父类成员/子类继承方式public继承protected继承private继承
父类的public成员变为子类的public成员变为子类protected成员变为子类的private成员
父类的protected成员变为子类的protected成员变为子类的protected成员变为子类的private成员
父类的private成员子类不可见子类不可见子类不可见

总结

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面
    都不能去访问它。

  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

  3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式等于Min{成员在基类的访问限定符，继承方式}，其中，public>protected>private。

  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

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

针对于总结中的第一点，父类private成员实际上还是被子类继承了，只是子类无法访问，下面使用代码验证↓↓↓

#include <iostream>
using namespace std;class Base
{
private:int _base;
};class Son : public Base
{}int main()
{Son s;return 0;
}

在这里插入图片描述

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

●派生类对象可以赋值给基类的对象/基类的指针/基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

在这里插入图片描述
下面给出代码示例↓↓↓

#include <iostream>
using namespace std;class Person
{
public:Person(){}Person(const string& name, const char& sex, const int& age):_name(name),_sex(sex),_age(age){}
protected:string _name;char _sex;int _age;
};class Student : public Person
{
public:Student(const string& name, const char& sex, const int& age, const int& stuId):Person(name, sex, age),_stuId(stuId){}
private:int _stuId;
};int main()
{Student s("Jammingpro", 'M', 18, 123456);Person p;p=s;return 0;
}

从监视窗口可以看到，Person对象保存了Student对象的父类成员部分，而舍弃了子类自有成员，这就是切片。
在这里插入图片描述

●基类对象不能赋值给派生类对象。（基类对象无法用于构造派生类对象，也无法使用派生类对象的拷贝赋值函数；但可以显示提供派生类赋值给基类的operator=实现）

★ps：由于派生类中的成员函数、成员对象一般情况下都会多于基类，如果基类直接赋值给派生类会导致部分成员数值不确定。因此，C++默认不提供基类赋值给派生类。

●基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针指向派生类对象时才是安全的。

下面代码演示了基类赋值给派生类指针，派生类赋值给基类指针↓↓↓

#include <iostream>
using namespace std;class Person
{
public:Person(){}Person(const string& name, const char& sex, const int& age):_name(name), _sex(sex), _age(age){}string _name;char _sex;int _age;
};class Student : public Person
{
public:Student(const string& name, const char& sex, const int& age, const int& stuId):Person(name, sex, age), _stuId(stuId){}int _stuId;
};int main()
{Student s("Jammingpro", 'M', 18, 123456);Person p("xiaoming", 'M', 20);Person* p_s = &s;//安全Student* s_p = (Student*) & p;//不安全cout << s_p->_stuId << endl;return 0;
}

为什么说，Student* s_p = (Student*) & p;是不安全的呢？由于Person对象中没有申请_stuId的空间，但在Student*类型看来，它认为它指向的对象有_stuId成员。如果用户访问了s_p->_stuId可能会因为内存非法访问而报错。
在这里插入图片描述

继承中的作用域

  1. 在继承体系中基类和派生类都有独立的作用域。
  2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
  3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏（而不需要返回值相同，或是参数列表相同）。
  4. 注意在实际中在继承体系里面最好不要定义同名的成员。

下面给出派生类成员变量与基类成员变量同名的例子↓↓↓
下面代码中，由于Son类中的成员变量与Base类中的成员变量重名，构成了隐藏。如果使用Son s; cout << s._name << endl;，则只能访问到Son对象中的成员变量，而无法访问到父类中的_name成员变量。若需要访问父类的_name成员变量，则可以使用类型+类作用域符号::来访问，即s.Base::_name。

#include <iostream>
using namespace std;class Base
{
public:string _name = "Jammingpro";
};class Son : public Base
{
public:string _name = "xiaoming";
};int main()
{Son s;cout << s._name << endl;cout << s.Base::_name << endl;return 0;
}

在这里插入图片描述
下面给出派生类成员函数与基类成员函数同名的例子↓↓↓这里与成员变量同名的情况相同，同名成员函数也会构成隐藏关系，如果需要访问父类的同名成员函数，需要使用类名+类作用域运算符::。

#include <iostream>
using namespace std;class Base
{
public:void Show(){cout << "I am _Base" << endl;}
};class Son : public Base
{
public:void Show(){cout << "I am _Son" << endl;}
};int main()
{Son s;s.Show();s.Base::Show();return 0;
}

在这里插入图片描述
★( ఠൠఠ )ﾉtest：下面的两个同名函数（函数名相同，参数列表不同）分别属于基类和派生类，它们构成的关系是隐藏还是函数重载呢？

#include <iostream>
using namespace std;class Base
{
public:void print(char ch){cout << "Base->" << ch << endl;}
};class Son : public Base
{
public:void print(int num){cout << "Son->" << num << endl;}
};int main()
{Son s;s.print('A');return 0;
}

在这里插入图片描述
Base中的成员函数比Son中的成员函数更匹配（不需要隐式类型转换），而这里还是调用Son中的成员函数，说明两者构成的关系是隐藏，而不是函数重载。这里要注意：在继承关系中，派生类与基类只要存在同名函数（不管参数列表、返回值是否相同），都是隐藏关系。

派生类的默认成员函数

6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

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

基类提供默认构造函数的情况
派生类在构造时，会自动调用基类的构造函数↓↓↓

#include <iostream>
using namespace std;class Base
{
public:Base(){cout << "Base() is called" << endl;}
};class Son : public Base
{
public:Son(){cout << "Son() is called" << endl;}
};int main()
{Son s;return 0;
}

在这里插入图片描述
基类没有提供默认构造函数的情况
基类没有提供默认构造时，子类必须在初始化参数列表中显示调用基类的构造函数，否则会报错。

#include <iostream>
using namespace std;class Base
{
public:Base(int b):_b(b){cout << "Base(int b) is called" << endl;}
private:int _b
};class Son : public Base
{
public:Son(int b):Base(b){cout << "Son() is called" << endl;}
};int main()
{Son s(5);return 0;
}

在这里插入图片描述

  1. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
#include <iostream>
using namespace std;class Base
{
public:Base(int b):_b(b){}Base(const Base& b){_b = b._b;cout << "Base(const Base& b) is called" << endl;}
private:int _b;
};class Son : public Base
{
public:Son(int s, int b):_s(s),Base(b){}Son(const Son& s):Base(s){_s = s._s;cout << "Son(const Son& s) is called" << endl;}
private:int _s;
};int main()
{Son s(55, 66);Son s2(s);return 0;
}

在这里插入图片描述
如果我们将上面代码中显示调用基类构造函数的代码去掉，则会出现如下报错↓↓↓
在这里插入图片描述
★ps：对于上面的报错，虽然可以通过给基类提供默认构造函数解决，但却无法完成子类中的基类成员的拷贝操作。

  1. 派生类的operator=可以调用基类的operator=完成基类的复制，这样可以避免代码冗余（这里派生类调用基类的operator=不是必须的，只是因为基类已经实现了该操作，派生类不必再重复编写相同内容）。

下面代码演示了派生类调用基类operator=函数带来的代码简化↓↓↓

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>
#include <string>
#include <cstring>
using namespace std;class Person
{
public:Person(const string& name, const int& age, const char& gender):_name(name),_age(age),_gender(gender){}Person& operator=(const Person& p){_name = p._name;_age = p._age;_gender = p._gender;return *this;}void Show(){cout << "My name is " << _name << ", I am " << _age << " years old, I am a " << (_gender == 'M' ? " boy " : "girl") << endl;}
private:string _name;int _age;char _gender;
};class Student : public Person
{
public:Student(const string& name, const int& age, const char& gender, const char* detail):Person(name, age, gender){_detail = new char[strlen(detail) + 1];strcpy(_detail, detail);}Student& operator=(const Student& s){Person::operator=(s);char* detail = new char[strlen(s._detail)];return *this;}void Show(){Person::Show();cout << "My detail infomation is " << _detail << endl;}~Student(){delete[] _detail;}
private:char* _detail;
};int main()
{Student s("Jammingpro", 18, 'M', "He is good at coding");Student copy = s;s.Show();
}

在这里插入图片描述

  1. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

  2. 派生类对象初始化先调用基类构造再调派生类构造。

下面代码演示了基类与派生类的构造与析构顺序↓↓↓

#include <iostream>
using namespace std;class Base
{
public:Base(){cout << "Base() is called" << endl;}~Base(){cout << "~Base() is deleted obj" << endl;}
};class Son : public Base
{
public:Son(){cout << "Son is called" << endl;}~Son(){cout << "~Son() is deleted obj" << endl;}
};int main()
{Son s;return 0;
}

在这里插入图片描述

  1. 编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

★ps：关于virtual关键字将于多态中讲解

继承与友元

友元关系不能不继承，也就是说：基类的友元不能访问派生类的私有和保护成员。

下面代码演示了友元关系无法继承↓↓↓

#include <iostream>
using namespace std;class Base
{friend void print();
private:int _base = 88;
};class Son : Base
{
private:int _son = 66;
};void print()
{Base b;cout << b._base << endl;Son s;cout << s._son << endl;
}int main()
{print();return 0;
}

在这里插入图片描述

继承与静态成员

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

#include <iostream>
using namespace std;class Base
{
public:static int val;
};//静态非const成员变量需要在类外初始化
int Base::val = 66;class Son : public Base
{
};class GrandSon : Son
{
};int main()
{cout << &Base::val << endl;cout << &Son::val << endl;cout << &GrandSon::val << endl;return 0;
}

在这里插入图片描述

复杂的菱形继承及菱形虚拟继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承
在这里插入图片描述
下面是一份单继承的代码↓↓↓

#include <iostream>
using namespace std;class Base
{
public:void base_func(){}int _base;
};class Son : public Base
{
public:void son_func(){}int _son;
};class GrandSon : public Son
{
public:void gs_func(){}int _gs;
};int main()
{GrandSon gs;cout << &gs << endl;gs._base = 1;cout << &gs._base << endl;gs._son = 2;cout << &gs._son << endl;gs._gs = 3;cout << &gs._gs << endl;cout << "===================================" << endl;Son s;cout << &s << endl;s._base = 1;cout << &s._base << endl;s._son = 2;cout << &s._son << endl;return 0;
}

在这里插入图片描述

上述代码调试时，通过监视窗口查看结果如下图所示。我们可以发现，GrandSon对象保存了其祖先类Son、Base的成员变量。Son对象保存了其基类成员变量。
在这里插入图片描述
下图为GrandSon对象的存储情况↓↓↓
在这里插入图片描述
通过分析上面的执行结果，可以得出如下结论：再单继承中，某个类的成员变量放置于类空间最后，该成员变量前放置的是直接父类，再往上是爷爷类，以此类推。类对象的地址，与最顶层的祖先的成员变量地址相同。

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
在这里插入图片描述
下面给出多继承的演示代码↓↓↓

#include <iostream>
using namespace std;class Base1
{
public:void base1_func(){}int _base1;
};class Base2
{
public:void base2_func(){}int _base2;
};class Son : public Base1, public Base2
{
public:void son_func(){}int _son;
};int main()
{Son s;cout << &s << endl;s._base1 = 1;cout << &s._base1 << endl;s._base2 = 2;cout << &s._base2 << endl;s._son = 3;cout << &s._son << endl;return 0;
}

在这里插入图片描述
如果Son先继承Base1再继承Base2，则会将Base1的成员变量放在前面，后继承的Base2的成员变量放在后面。
在这里插入图片描述
如果将Son先继承Base2，再继承Base1呢？
在这里插入图片描述

由上面的执行结果可知，先继承的基类的成员变量放置于类对象的前面位置，后即成的基类的成员变量放置于类对象的后面位置，类自身的成员变量放置于最后。

菱形继承：菱形继承是多继承的一种特殊情况
在这里插入图片描述
下面给出多继承的演示代码↓↓↓

#include <iostream>
using namespace std;class Share
{
public:void share_func(){}int _share;
};class Base1 : Share
{
public:void base1_func(){}int _base1;
};class Base2 : Share
{
public:void base2_func(){}int _base2;
};class Son : public Base1, public Base2
{
public:void son_func(){}int _son;
};int main()
{Son s;s._base1 = 1;s._base2 = 2;s._son = 3;return 0;
}

在上述代码的监视窗口可以看出菱形继承有数据冗余和二义性的问题。s中继承了两份Share类的成员变量_share。
在这里插入图片描述
C++中为了避免菱形继承导致的数据冗余和二义性，它引入了虚拟继承。虚拟继承可以解决菱形继承的二义性和数据冗余的问题。下面给出修改后的代码（引入虚拟继承的代码）↓↓↓

#include <iostream>
using namespace std;class Share
{
public:void share_func(){}int _share;
};class Base1 : virtual public Share
{
public:void base1_func(){}int _base1;
};class Base2 : virtual public Share
{
public:void base2_func(){}int _base2;
};class Son : public Base1, public Base2
{
public:void son_func(){}int _son;
};int main()
{Son s;cout << &s << endl;s._share = 0;cout << &s._share << endl;s._base1 = 1;cout << &s._base1 << endl;s._base2 = 2;cout << &s._base2 << endl;s._son = 3;cout << &s._son << endl;return 0;
}

在这里插入图片描述

在这里插入图片描述

这里是通过了两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的Share。

🎈欢迎进入浅尝C++专栏，查看更多文章。
如果上述内容有任何问题，欢迎在下方留言区指正b(￣▽￣)d

这篇关于【浅尝C++】继承机制=＞虚基表/菱形虚继承/继承的概念、定义/基类与派生类对象赋值转换/派生类的默认成员函数等详解的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/880007。

相关文章

Oracle的to_date()函数详解

Oracle的to_date()函数详解

《Oracle的to_date()函数详解》Oracle的to_date()函数用于日期格式转换,需要注意Oracle中不区分大小写的MM和mm格式代码,应使用mi代替分钟,此外,Oracle还支持毫... 目录oracle的to_date()函数一.在使用Oracle的to_date函数来做日期转换二.日
阅读更多...
Java实现任务管理器性能网络监控数据的方法详解

Java实现任务管理器性能网络监控数据的方法详解

《Java实现任务管理器性能网络监控数据的方法详解》在现代操作系统中,任务管理器是一个非常重要的工具,用于监控和管理计算机的运行状态,包括CPU使用率、内存占用等,对于开发者和系统管理员来说,了解这些... 目录引言一、背景知识二、准备工作1. Maven依赖2. Gradle依赖三、代码实现四、代码详解五
阅读更多...
JAVA中整型数组、字符串数组、整型数和字符串 的创建与转换的方法

JAVA中整型数组、字符串数组、整型数和字符串 的创建与转换的方法

《JAVA中整型数组、字符串数组、整型数和字符串的创建与转换的方法》本文介绍了Java中字符串、字符数组和整型数组的创建方法,以及它们之间的转换方法,还详细讲解了字符串中的一些常用方法,如index... 目录一、字符串、字符数组和整型数组的创建1、字符串的创建方法1.1 通过引用字符数组来创建字符串1.2
阅读更多...
深入理解C++ 空类大小

深入理解C++ 空类大小

《深入理解C++空类大小》本文主要介绍了C++空类大小,规定空类大小为1字节,主要是为了保证对象的唯一性和可区分性,满足数组元素地址连续的要求,下面就来了解一下... 目录1. 保证对象的唯一性和可区分性2. 满足数组元素地址连续的要求3. 与C++的对象模型和内存管理机制相适配查看类对象内存在C++中，规
阅读更多...
Mysql 中的多表连接和连接类型详解

Mysql 中的多表连接和连接类型详解

《Mysql中的多表连接和连接类型详解》这篇文章详细介绍了MySQL中的多表连接及其各种类型,包括内连接、左连接、右连接、全外连接、自连接和交叉连接,通过这些连接方式,可以将分散在不同表中的相关数据... 目录什么是多表连接？1. 内连接（INNER JOIN）2. 左连接（LEFT JOIN 或 LEFT
阅读更多...
Java中switch-case结构的使用方法举例详解

Java中switch-case结构的使用方法举例详解

《Java中switch-case结构的使用方法举例详解》：本文主要介绍Java中switch-case结构使用的相关资料,switch-case结构是Java中处理多个分支条件的一种有效方式,它... 目录前言一、switch-case结构的基本语法二、使用示例三、注意事项四、总结前言对于Java初学者
阅读更多...
Linux内核之内核裁剪详解

Linux内核之内核裁剪详解

《Linux内核之内核裁剪详解》Linux内核裁剪是通过移除不必要的功能和模块,调整配置参数来优化内核,以满足特定需求,裁剪的方法包括使用配置选项、模块化设计和优化配置参数,图形裁剪工具如makeme... 目录简介一、 裁剪的原因二、裁剪的方法三、图形裁剪工具四、操作说明五、make menuconfig
阅读更多...
更改docker默认数据目录的方法步骤

更改docker默认数据目录的方法步骤

《更改docker默认数据目录的方法步骤》本文主要介绍了更改docker默认数据目录的方法步骤,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一... 目录1.查看docker是否存在并停止该服务2.挂载镜像并安装rsync便于备份3.取消挂载备份和迁
阅读更多...
详解Java中的敏感信息处理

详解Java中的敏感信息处理

《详解Java中的敏感信息处理》平时开发中常常会遇到像用户的手机号、姓名、身份证等敏感信息需要处理,这篇文章主要为大家整理了一些常用的方法,希望对大家有所帮助... 目录前后端传输AES 对称加密RSA 非对称加密混合加密数据库加密MD5 + Salt/SHA + SaltAES 加密平时开发中遇到像用户的
阅读更多...
Springboot使用RabbitMQ实现关闭超时订单(示例详解)

Springboot使用RabbitMQ实现关闭超时订单(示例详解)

《Springboot使用RabbitMQ实现关闭超时订单(示例详解)》介绍了如何在SpringBoot项目中使用RabbitMQ实现订单的延时处理和超时关闭,通过配置RabbitMQ的交换机、队列和... 目录1.maven中引入rabbitmq的依赖：2.application.yml中进行rabbit
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2