AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

C++入门11——详解C++继承（菱形继承与虚拟继承）-2

2024-10-10 217
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C++入门11——详解C++继承（菱形继承与虚拟继承）-2

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

在C++入门3——类与对象2（类的6个默认成员函数）中，我们已经学习了类的6个默认成员函数：

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

1.构造函数

默认构造函数

我们知道，默认生成的构造函数对自定义类型调用它的默认成员函数，而内置类型则不做处理。

与普通类相同，派生类（子类）成员默认生成的构造函数处理机制也分为自定义类型和内置类型。

不同的仅仅是派生类构造函数运行的同时多了一个基类的运行，而基类成员则调用基类的构造函数，即：自己调用自己的构造函数，互不掺和。

class Person
{
public:
  Person(const char* name = "张三")
    : _name(name)
  {
    cout << "父类构造Person()" << endl;
  }
protected:
  string _name; // 姓名
};
 
class Student :Person
{
public:
 
private:
  int _stuid = 2020060410;
};
 
int main()
{
  Student s1;
  return 0;
}

自定义构造函数

现在我要自己定义构造函数：

class Student :Person
{
public:
  Student(const char* name, int id)
    :_name(name)
    ,_stuid(id)
  {
        cout << "子类构造Student()" << endl;
    }
private:
  int _stuid = 2020060410;
};

结果却报错了：

因为我们上面说过了：父子互不掺和，不能用儿子的构造函数去构造父亲，想在儿子这里构造父亲，就必须显示调用父亲的构造函数，所以正确的写法应该是：

class Student :Person
{
public:
  Student(const char* name, int id)
    //:_name(name)//error:说过了互不掺和，不能用儿子的构造函数去构造父亲
    :Person(name)//想在儿子这里构造父亲，就必须显示调用父亲的构造函数
    ,_stuid(id)
  {
        cout << "子类构造Student()" << endl;
    }
private:
  int _stuid = 2020060410;
};

（在这里插播一个小问题：父与子的构造顺序是怎样的呢？是先父后子还是先子后父呢？

答案一定是先父后子的，因为我们在C++入门4——类与对象3（构造函数的类型转换和友元详解）中提到过这个问题：初始化列表初始化的顺序跟出现的顺序无关，跟声明的顺序有关！

所以这里即使将id放在name的前面，结果都是父亲先构造，因为父亲的声明在前，儿子的声明在后！）

2.拷贝构造

默认拷贝构造

知道了构造函数，拷贝构造与构造函数相同：

class Person
{
public:
  Person(const char* name = "张三")
    : _name(name)
  {
    cout << "父类构造Person()" << endl;
  }
  Person(const Person& p)
    : _name(p._name)
  {
    cout << "父类拷贝构造Person(const Person& p)" << endl;
  }
protected:
  string _name; // 姓名
};
 
class Student :Person
{
public:
  Student(const char* name, int id)
    :Person(name)
    ,_stuid(id)
  {
        cout << "子类构造Student()" << endl;
    }
private:
  int _stuid = 2020060410;
};
 
int main()
{
  Student s1("李四", 20);
  Student s2(s1);
  return 0;
}

自定义拷贝构造

自定义拷贝构造与自定义构造函数相同，也必须显示调用父亲的拷贝构造函数，可是问题来了：

父类的拷贝构造函数要怎么调用呢？怎么把子类当中父类的那部分数据取出来呢？

此处就用到了2.基类和派生类对象赋值转换的知识：按照赋值兼容原则：父类把子类那部分切来赋值过去，代码如下：

class Person
{
public:
  Person(const char* name = "张三")
    : _name(name)
  {
    cout << "父类构造Person()" << endl;
  }
  Person(const Person& p)
    : _name(p._name)
  {
    cout << "父类拷贝构造Person(const Person& p)" << endl;
  }
protected:
  string _name; // 姓名
};
 
class Student :Person
{
public:
  Student(const char* name, int id)
    :Person(name)
    ,_stuid(id)
  {
        cout << "子类构造Student()" << endl;
    }
  Student(const Student& s)
    :Person(s)
    ,_stuid(s._stuid)
  {
        cout << "子类拷贝构造Student(const Student& s)" << endl;
    }
private:
  int _stuid = 2020060410;
};
 
int main()
{
  Student s1("李四", 20);
  Student s2(s1);
  return 0;
}

3.赋值重载

默认赋值重载与前面两个默认成员函数一样，此处重点注意一下自定义赋值重载：

class Student :Person
{
public:
  Student(const char* name, int id)
    :Person(name)
    ,_stuid(id)
  {
        cout << "子类构造Student()" << endl;
    }
  Student(const Student& s)
    :Person(s)
    ,_stuid(s._stuid)
  {
        cout << "子类拷贝构造Student(const Student& s)" << endl;
    }
  Student& operator=(const Student& s)
  {
        cout << "子类赋值重载Student& operator=(const Student& s)" << endl;
    if (this != &s)
    {
      operator=(s);
      _stuid = s._stuid;
    }
    return *this;
  }
private:
  int _stuid = 2020060410;
};

发现栈溢出了！

这是什么原因呢？

没错！正是前面3.继承中的作用域 中讲的隐藏问题：父类的operator函数与子类的operator函数名字相同，达成了隐藏条件，所以在此处父类的operator被隐藏了，这里一直调用的都是子类的operator函数，因此才导致了栈溢出！

正确代码：

class Person
{
public:
  Person(const char* name = "张三")
    : _name(name)
  {
    cout << "父类构造Person()" << 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;
  }
protected:
  string _name; // 姓名
};
 
class Student :Person
{
public:
  Student(const char* name, int id)
    :Person(name)
    ,_stuid(id)
  {
        cout << "子类构造Student()" << endl;
    }
  Student(const Student& s)
    :Person(s)
    ,_stuid(s._stuid)
  {
        cout << "子类拷贝构造Student(const Student& s)" << endl;
    }
  Student& operator=(const Student& s)
  {
        cout << "子类赋值重载Student& operator=(const Student& s)" << endl;
    if (this != &s)
    {
      Person::operator=(s);
      _stuid = s._stuid;
    }
    return *this;
  }
private:
  int _stuid = 2020060410;
};
 
int main()
{
  Student s1("李四", 20);
  Student s2(s1);
  Student s3("王五",30);
  s2 = s3;
  return 0;
}

4.析构函数

子类的析构函数与父类的析构函数构成隐藏关系，由于后面多态的原因，析构函数会被特殊处理，函数名都会被处理成destrutor()，为了保证先子后父的析构顺序，父类的析构会在子类的析构后自动调用。

class Student :Person
{
public:
  Student(const char* name, int id)
    :Person(name)
    , _stuid(id)
  {
    cout << "子类构造Student()" << endl;
  }
  Student(const Student& s)
    :Person(s)
    , _stuid(s._stuid)
  {
    cout << "子类拷贝构造Student(const Student& s)" << endl;
  }
  Student& operator=(const Student& s)
  {
    cout << "子类赋值重载Student& operator=(const Student& s)" << endl;
    if (this != &s)
    {
      Person::operator=(s);
      _stuid = s._stuid;
    }
    return *this;
  }
  ~Student()
  {
    //Person::~Person();
    cout << "子类析构函数~Student()" << endl;
  }
private:
  int _stuid = 2020060410;
};

（再插播一个小问题：前面说了构造是先父后子，这里的析构确是先子后父，这是为什么呢？

假设析构函数也是先父后子，那么父类资源先被清理释放了，我子类又要去访问父类的资源，就会存在野指针等风险）

总结：

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

2. 子类的拷贝构造函数必须调用父类的拷贝构造完成父类的拷贝初始化。

3. 子类的operator=必须要调用父类的operator=完成父类的复制。

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

5. 子类对象初始化先调用父类构造再调用子类构造。

6. 子类对象析构清理先调用子类析构再调父类的析构。

7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后续再详细探究)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加 virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

5.继承中的友元与静态成员

5.1继承与友元

这里就一句话：

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

通俗点说，爸爸的朋友不是你的朋友，你如果也想跟爸爸的朋友做朋友，就需要爸爸引荐。

5.2继承与静态成员

这里也只有一句话：

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

根据这个性质，我们就可以统计这个继承体系中一共出现了多少个对象：

class Person
{
public:
  Person() 
  { 
    ++_count;
  }
protected:
  string _name; // 姓名
public:
  static int _count; // 统计人的个数。
};
int Person::_count = 0;
 
class Student :public Person
{
protected:
  int _stuid;
};
 
int main()
{
  Student s1;
  Student s2;
  Student s3;
  Student s4;
  cout << "人数：" << Person::_count << endl;
  return 0;
}

*6.复杂的菱形继承及菱形虚拟继承

6.1单继承与多继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

菱形继承：菱形继承是多继承的一种特殊情况。

6.2菱形继承的问题

C++中多继承的初衷显然是好的，它希望一个类可以同时拥有两个类的功能。

class Person
{
public:
  string _name;
  int _age;
};
class Student:public Person
{
protected:
  int _stuid;
};
 
class Teacher :public Person
{
protected:
  int _tecid;
};
class Schoool :public Student, public Teacher
{
protected:
  string address;
};

可是这么做也存在一定的问题：有了多继承就有可能出现上面所说的菱形继承，比如：School对象中Person的成员会有两份：

int main()
{
  School x1;
  //x1._name = "王五";//error："School::_name" 不明确
  x1.Student::_name = "张三";
  x1.Teacher::_name = "张老师";
  return 0;
}

需要显示指定访问哪个父类的成员可以解决二义性问题，我在学生里面叫张三，在老师里面叫张老师，显示指定访问哪个父类就解决了二义性问题，但是我的年龄呢？电话呢？家庭住址呢？这些数据总是唯一的吧，我们在两个类分别存一个，这虽然暂时解决了二义性问题，可终归治标不治本，这样做又会导致数据的冗余。

如何解决这个问题呢？

6.3虚拟继承

虚拟继承可以解决菱形继承的二义性和数据冗余问题。如上面的继承关系，在Student和 Teacher继承Person时使用虚拟继承(virtual)，即可解决问题。

具体用法如下：

class Person
{
public:
  string _name;
  int _age;
};
 
class Student :virtual public Person
{
protected:
  int _stuid;
};
 
class Teacher :virtual public Person
{
protected:
  int _tecid;
};
 
class School :public Student, public Teacher
{
protected:
  string address;
};
 
int main()
{
  School x1;
  x1._name = "王五";
  return 0;
}

7.C++11中的final关键字

有这样一个问题：让你实现一个类，使这个类不能被继承？

方法1：将这个类的构造函数私有化：

class A
{
public:
protected:
  int _a;
private:
  A()
  {
 
  }
};
 
class B :public A
{
 
};

这样写程序不会报错，可是我们实例化子类对象时情况就不对了：

int main()
{
  B bb;
  return 0;
}

因为派生类的构造必须先去调用基类的构造，可是基类的构造被private了，所以派生类自然而然实例不出对象。

方法2：C++11中增加final，final修饰的类为最终类，不能被继承

方法1那样的做法可以达到目的，可是只有在实例化子类对象时才会报错，于是C++11就引入了final：

class A final
{
public:
protected:
  int _a;
private:
  A()
  {
 
  }
};
 
class B :public A
{
 
};

（本篇完）

文章标签：
C++
编译器
关键词：
C++继承
C++入门
C++菱形虚拟继承
C++继承菱形
C++入门继承
徐霞客320
目录
相关文章
游客eh6e4jo3ixv7i
|
5月前
|
安全 Java 编译器
C++进阶（1）——继承
本文系统讲解C++继承机制，涵盖继承定义、访问限定符、派生类默认成员函数、菱形虚拟继承原理及组合与继承对比，深入剖析其在代码复用与面向对象设计中的应用。
游客eh6e4jo3ixv7i
424 3
hahaha无
|
9月前
|
存储 安全 Java
c++--继承
c++作为面向对象的语言三大特点其中之一就是继承，那么继承到底有何奥妙呢？继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用，继承就是类方法的复用。
hahaha无
190 0
hahaha无
|
9月前
|
存储 安全 编译器
c++入门
c++作为面向对象的语言与c的简单区别：c语言作为面向过程的语言还是跟c++有很大的区别的，比如说一个简单的五子棋的实现对于c语言面向过程的设计思路是首先分析解决这个问题的步骤：（1）开始游戏（2）黑子先走（3）绘制画面（4）判断输赢（5）轮到白子（6）绘制画面（7）判断输赢（8）返回步骤（2） （9）输出最后结果。但对于c++就不一样了，在下五子棋的例子中，用面向对象的方法来解决的话，首先将整个五子棋游戏分为三个对象:（1）黑白双方，这两方的行为是一样的。（2）棋盘系统，负责绘制画面。
hahaha无
131 0
平凡程序猿~
|
存储 缓存 C++
C++ 容器全面剖析：掌握 STL 的奥秘，从入门到高效编程
C++ 标准模板库（STL）提供了一组功能强大的容器类，用于存储和操作数据集合。不同的容器具有独特的特性和应用场景，因此选择合适的容器对于程序的性能和代码的可读性至关重要。对于刚接触 C++ 的开发者来说，了解这些容器的基础知识以及它们的特点是迈向高效编程的重要一步。本文将详细介绍 C++ 常用的容器，包括序列容器（`std::vector`、`std::array`、`std::list`、`std::deque`）、关联容器（`std::set`、`std::map`）和无序容器（`std::unordered_set`、`std::unordered_map`），全面解析它们的特点、用法
平凡程序猿~
750 1
C++ 容器全面剖析：掌握 STL 的奥秘，从入门到高效编程
预备女程序员a
|
12月前
|
存储 分布式计算 编译器
C++入门基础2
本内容主要讲解C++中的引用、inline函数和nullptr。引用是变量的别名，与原变量共享内存，定义时需初始化且不可更改指向对象，适用于传参和返回值以提高效率；const引用可增强代码灵活性。Inline函数通过展开提高效率，但是否展开由编译器决定，不建议分离声明与定义。Nullptr用于指针赋空，取代C语言中的NULL。最后鼓励持续学习，精进技能，提升竞争力。
预备女程序员a
194 1
ephemerals__
|
安全 C++
【c++】继承（继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员）
本文深入探讨了C++中的继承机制，作为面向对象编程（OOP）的核心特性之一。继承通过允许派生类扩展基类的属性和方法，极大促进了代码复用，增强了代码的可维护性和可扩展性。文章详细介绍了继承的基本概念、定义格式、继承方式（public、protected、private）、赋值兼容转换、作用域问题、默认成员函数规则、继承与友元、静态成员、多继承及菱形继承问题，并对比了继承与组合的优缺点。最后总结指出，虽然继承提高了代码灵活性和复用率，但也带来了耦合度高的问题，建议在“has-a”和“is-a”关系同时存在时优先使用组合。
ephemerals__
729 6
预备女程序员a
|
C++
C++入门基础
C++入门
预备女程序员a
210 1
RossyYan
|
编译器 数据安全/隐私保护 C++
【C++面向对象——继承与派生】派生类的应用（头歌实践教学平台习题）【合集】
本实验旨在学习类的继承关系、不同继承方式下的访问控制及利用虚基类解决二义性问题。主要内容包括： 1. **类的继承关系基础概念**：介绍继承的定义及声明派生类的语法。 2. **不同继承方式下对基类成员的访问控制**：详细说明`public`、`private`和`protected`继承方式对基类成员的访问权限影响。 3. **利用虚基类解决二义性问题**：解释多继承中可能出现的二义性及其解决方案——虚基类。 实验任务要求从`people`类派生出`student`、`teacher`、`graduate`和`TA`类，添加特定属性并测试这些类的功能。最终通过创建教师和助教实例，验证代码
RossyYan
417 5
平凡程序猿~
|
编译器 C++ 开发者
【C++篇】深度解析类与对象（下）
在上一篇博客中，我们学习了C++的基础类与对象概念，包括类的定义、对象的使用和构造函数的作用。在这一篇，我们将深入探讨C++类的一些重要特性，如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象，以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念，提升代码的健壮性、灵活性和可维护性。
平凡程序猿~
336 0
ephemerals__
|
11月前
|
编译器 C++ 容器
【c++11】c++11新特性（上）（列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式）
C++11为C++带来了革命性变化，引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式，initializer_list简化了容器多元素初始化；右值引用和移动语义优化了资源管理，减少拷贝开销；类新增移动构造和移动赋值函数提升性能；lambda表达式提供匿名函数对象，增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展，提升了开发效率与程序性能。
ephemerals__
426 12