【浅尝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。

相关文章

Python打印对象所有属性和值的方法小结

Python打印对象所有属性和值的方法小结

《Python打印对象所有属性和值的方法小结》在Python开发过程中,调试代码时经常需要查看对象的当前状态,也就是对象的所有属性和对应的值,然而,Python并没有像PHP的print_r那样直接提... 目录python中打印对象所有属性和值的方法实现步骤1. 使用vars()和pprint()2. 使
阅读更多...
CSS place-items: center解析与用法详解

CSS place-items: center解析与用法详解

《CSSplace-items:center解析与用法详解》place-items:center;是一个强大的CSS简写属性，用于同时控制网格(Grid)和弹性盒(Flexbox)... place-items: center; 是一个强大的 css 简写属性，用于同时控制 网格(Grid) 和 弹性盒(F
阅读更多...
CSS Anchor Positioning重新定义锚点定位的时代来临(最新推荐)

CSS Anchor Positioning重新定义锚点定位的时代来临(最新推荐)

《CSSAnchorPositioning重新定义锚点定位的时代来临(最新推荐)》CSSAnchorPositioning是一项仍在草案中的新特性，由Chrome125开始提供原生支持需... 目录 css Anchor Positioning：重新定义「锚定定位」的时代来了！ 什么是 Anchor Pos
阅读更多...
spring中的ImportSelector接口示例详解

spring中的ImportSelector接口示例详解

《spring中的ImportSelector接口示例详解》Spring的ImportSelector接口用于动态选择配置类,实现条件化和模块化配置,关键方法selectImports根据注解信息返回... 目录一、核心作用二、关键方法三、扩展功能四、使用示例五、工作原理六、应用场景七、自定义实现Impor
阅读更多...
nginx启动命令和默认配置文件的使用

nginx启动命令和默认配置文件的使用

《nginx启动命令和默认配置文件的使用》：本文主要介绍nginx启动命令和默认配置文件的使用,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录常见命令nginx.conf配置文件location匹配规则图片服务器总结常见命令# 默认配置文件启动./nginx
阅读更多...
PostgreSQL 默认隔离级别的设置

PostgreSQL 默认隔离级别的设置

《PostgreSQL默认隔离级别的设置》PostgreSQL的默认事务隔离级别是读已提交,这是其事务处理系统的基础行为模式,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价... 目录一 默认隔离级别概述1.1 默认设置1.2 各版本一致性二 读已提交的特性2.1 行为特征2.2
阅读更多...
Windows下C++使用SQLitede的操作过程

Windows下C++使用SQLitede的操作过程

《Windows下C++使用SQLitede的操作过程》本文介绍了Windows下C++使用SQLite的安装配置、CppSQLite库封装优势、核心功能（如数据库连接、事务管理）、跨平台支持及性能优... 目录Windows下C++使用SQLite1、安装2、代码示例CppSQLite：C++轻松操作SQ
阅读更多...
一文深入详解Python的secrets模块

一文深入详解Python的secrets模块

《一文深入详解Python的secrets模块》在构建涉及用户身份认证、权限管理、加密通信等系统时,开发者最不能忽视的一个问题就是“安全性”,Python在3.6版本中引入了专门面向安全用途的secr... 目录引言一、背景与动机：为什么需要 secrets 模块？二、secrets 模块的核心功能1. 基
阅读更多...
PostgreSQL中MVCC 机制的实现

PostgreSQL中MVCC 机制的实现

《PostgreSQL中MVCC机制的实现》本文主要介绍了PostgreSQL中MVCC机制的实现,通过多版本数据存储、快照隔离和事务ID管理实现高并发读写,具有一定的参考价值,感兴趣的可以了解一下... 目录一 MVCC 基本原理python1.1 MVCC 核心概念1.2 与传统锁机制对比二 Postg
阅读更多...
一文详解MySQL如何设置自动备份任务

一文详解MySQL如何设置自动备份任务

《一文详解MySQL如何设置自动备份任务》设置自动备份任务可以确保你的数据库定期备份,防止数据丢失,下面我们就来详细介绍一下如何使用Bash脚本和Cron任务在Linux系统上设置MySQL数据库的自... 目录1. 编写备份脚本1.1 创建并编辑备份脚本1.2 给予脚本执行权限2. 设置 Cron 任务2
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2