C++——继承

已于 2023-06-15 10:34:06 修改
阅读量687 收藏 4
点赞数 6
分类专栏： C++ 文章标签： c++ 继承 Powered by 金山文档
于 2023-03-11 20:17:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57249790/article/details/129466739
版权

概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特

性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，

体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

定义

class Person
{
public:
    Person(const char* name="mwb")
    {}
    void print()
    {
        cout << "name: " << _name << endl;
        cout<<"age: " << _age << endl;
    }
private:
    string _name = "peter";
    int _age = 18;
};

class Student : public Person
{
public:
    Student(const char* name, int num)
        :Person(name)
        , _num(num)
    {}
protected:
    int  _stuid = 0;
    int _num = 111;
};

class Teacher : public Person
{
protected:
    int  _jobid = 0;
    int _num = 999;
};

基类和派生类进行赋值转换

赋值兼容规则：

赋值兼容规则是指在需要基类对象的任何地方都可以使用公有派生类的对象来替代。通过公有继承，派生类得到了基类中除构造函数、析构函数之外的所有成员，而且所有成员的访问控制属性也和基类完全相同。这样，公有派生类实际就具备了基类的所有功能，凡是基类能解决的问题，公有派生类都可以解决。赋值兼容规则中所指的替代包括以下的情况：

  1. 派生类的对象可以赋值给基类对象。

  1. 派生类的对象可以初始化基类的引用。

  1. 派生类对象的地址可以赋给指向基类的指针。

在替代之后，派生类对象就可以作为基类的对象使用，但只能使用从基类继承的成员。

何为切片

注意：子类赋值给父类的时候会发生切片。

class Person
{
protected :
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public :
int _No ; // 学号
};

若执行以下代码，就会发生如图所示的切片：

Student S;
Person& rp=S;

如图所示：

解析：顾名思义就是将子类对象中的成员直接给给父类对象，虽然类型不同但是也没有产生临时变量。

与非切片类型转换的区别：

int a=1;
double b=2.2;
double& ra=a;

与之相似的以上代码就是错误的，由于ra的类型与a不同，当类型转换的时候，a需要生成一个临时变量，然而临时变量是常量，引用不能引用一个常量，所以应该在double前面加一个const修饰一下。

即为：

int a=1;
double b=2.2;
const double& ra=a;

作用域

隐藏

概念：

1、子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定

义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）

2、 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

成员变量的隐藏

代码如下：

class Person
{
public:
    int _num = 1;
};
class Student : public Person
{
public:
    int _num = 2;
};
int main()
{
    Student s;
    cout << s._num << endl;
    return 0;
}

由于构成隐藏，所以s对象会屏蔽基类对同名成员的直接访问。

如果想访问父类中的成员变量可以在成员变量前加一个作用域限定一下。

class Person
{
public:
    int _num = 1;
};
class Student : public Person
{
public:
    int _num = 2;
};
int main()
{
    Student s;
    cout << s.Person::_num << endl;
    return 0;
}

成员函数的隐藏


class Person
{
public:
    void fun(int _num = 999)
    {
        cout << _num << endl;
    }
    int _num = 1;
};
class Student : public Person
{
public:
    void fun(const char* name = "mwb", int _num = 666)
    {
        cout <<name<< _num << endl;
    }
    string name;
    int _num = 2;
};
int main()
{
    Student s;
    s.fun();
    return 0;
}

由于构成隐藏，所以s对象会屏蔽基类对同名成员的直接访问。

如果想访问父类中的成员变量可以在成员函数前加一个作用域限定一下。


class Person
{
public:
    void fun(int _num = 999)
    {
        cout << _num << endl;
    }
    int _num = 1;
};
class Student : public Person
{
public:
    void fun(const char* name = "mwb", int _num = 666)
    {
        cout <<name<< _num << endl;
    }
    string name;
    int _num = 2;
};
int main()
{
    Student s;
    s.Person::fun();
    return 0;
}

派生类的默认成员函数

重中之重:

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函

数，则必须在派生类构造函数的初始化列表阶段显示调用。

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

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

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

对象先清理派生类成员再清理基类成员的顺序。

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

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

构造、拷贝构造、赋值重载

class Person
{
public:
    //构造
    Person(const char* name="peter")
    //如果在这里没有初始化就必须在派生类构造函数的初始化列表进行初始化
        :_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;
    }
    ~Person()
    {
        cout << "~Person()" << endl;
    }
protected:
    string _name;
};

//派生类中
//1、构造函数，父类成员调用父类的构造函数完成初始化
class Student : public Person
{
public:
    //构造
    Student(const char* name="mawenbo", int num=3)
        :Person(name)
        , _num(num)
    {}
    Student(const Student& s)
        :Person(s)//必须调用基类的拷贝构造进行初始化
        ,_num(s._num)
    {}
    Student& operator=(const Student& s)
    {
        if (this != &s)
        {
            Person::operator=(s);//这里如果不调用基类的将一直循环
            //operator=(s);
            _num = s._num;
        }
        return *this;
    }
protected:
    int _num;
};

int main()
{
    return 0;
}

析构


class Person
{
public:
    Person()
    {
        cout << "Person()" << endl;
    }
    ~Person()
    {
        cout << "~Person()" << endl;
    }
};
class Student : public Person
{
public:
    Student()
    {
        cout << "Student()" << endl;
    }
    ~Student()
    {
        cout << "~Student()" << endl;
    }
};
int main()
{
    Student s;
    return 0;
}

由运行结果我们可以得出以下几点：

  1. 派生类初始化先调用基类构造函数再调用派生类构造函数。

  1. 清理的时候先调用派生类的析构再调用基类的析构。

  1. 调用派生类析构函数的后会自动去调用基类的析构函数，这也为了满足派生类的析构函数一定先于基类的析构函数调用。

继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员，好比你爸爸的朋友不一定就是你的朋友。

继承与静态成员


class Person
{
public:
    Person()
    {
        _count++;
    }
    void Print()
    {
        cout << _count << endl;
    }
public:
    static int _count;
};

int Person::_count = 0;
class Student : public Person
{
public:
    Student()
    {
        Person::_count++;
    }
    void Print()
    {
        cout << Person::_count++ << endl;
    }
};


int main()
{
    Person p;
    p.Print();
    Student s;
    s.Print();
    cout << Person::_count << endl;
    Person::_count = 3;
    cout << Person::_count << endl;

    Person::_count = 99;
    cout << Person::_count << endl;

}

解析：静态变量不属于任何对象，属于全局。当无论在哪里改变出了作用域都会改变。

菱形继承

概述


class A
{
public:
    int _a;
};
class B : public A
{
public:
    int _b;
};
class C : public A
{
public:
    int _c;
};
class D :public B, public C
{
public:
    int _d;
};

顾名思义，继承的关系像一个菱形一样，如上图所示。

菱形继承的二义性与改进方法（菱形虚拟继承）

二义性

先看代码：

class A
{
public:
    int _a;
};
class B : public A
{
public:
    int _b;
};
class C : public A
{
public:
    int _c;
};
class D :public B, public C
{
public:
    int _d;
};
int main()
{
    D d;
    d._a;
    return 0;
}

由于B和C里面都有A继承下来的_a，此时我们使用d去访问_a时就会产生二义性，编译器会不知道到底应该访问哪个_a。

菱形虚拟继承

代码如下：

class A
{
public:
    int _a;
};
class B : virtual public A
{
public:
    int _b;
};
class C : virtual public A
{
public:
    int _c;
};
class D :public B, public C
{
public:
    int _d;
};

我们只需要在继承方式的前面，也就是菱形的腰部位置加两个virtual，就构成了菱形虚拟继承。

此时我们再用d去访问_a就不会报错了，因为此时菱形虚拟继承已经吧B和C中的_a当成一个变量来处理了。

原理

代码如下：

虚拟继承之前

class A
{
public:
    int _a;
};
class B : public A
{
public:
    int _b;
};
class C : public A
{
public:
    int _c;
};
class D :public B, public C
{
public:
    int _d;
};
int main()
{

    D d;
    d.B::_a = 1;
    d.C::_a = 2;
    d._b = 3;
    d._c = 4;
    d._d = 5;

    return 0;
}

内存情况:

我们去查看内存的时候发现B和C中的_a是两个值，因而导致二义性。

虚拟继承后

代码如下：

class A
{
public:
    int _a;
};
class B : virtual public A
{
public:
    int _b;
};
class C : virtual public A
{
public:
    int _c;
};
class D :public B, public C
{
public:
    int _d;
};
int main()
{

    D d;
    d.B::_a = 1;
    d.C::_a = 2;
    d._b = 3;
    d._c = 4;
    d._d = 5;

    return 0;
}

内存情况：

我们发现此时B和C中的_a已经成为一个值了，那么在内存中是怎样实现的呢，并且我们发现在内存中_a被放在了最下边独立于其他成员变量。

我们发现在_b和_c的存储位置上方有一个虚基表指针，我们在内存中去使用他们的指针所指向的地址可以找到他们对应的值，叫做偏移量，当我们用虚基表指针自身的地址与偏移量相加可获得_a的地址，因此内存就是以这种方式来寻找_a存放的位置的。

注意：

很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有

菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在

复杂度及性能上都有问题。多继承可以认为是C++的缺陷之一，很多后来的OO语言(Object Oriented,OO,也就是面向对象的语言)都没有多继承，如Java。

组合


//继承 is-a关系
class Person
{
protected:
    string _name;
};
class Student : public Person
{
protected:
    int _id;
};


//组合 has-a关系
class Hair
{
protected:
    string _colour;
};
class Animal
{
protected:
    int _age;
    Hair h;
};

组合的耦合度低，继承的耦合度高，能使用组合就不使用继承，因为继承一定程度的破坏了代码的封装，派生类和基类的依赖关系很强。

袁百万
关注
  • 6
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
详解C++基础——类继承
12-31
好吧，本系列博客已经变成了《C++ Primer Plus》的读书笔记，尴尬。在使用C语言时，多通过添加库函数的方式实现代码重用，但有一个弊端就是原来写好的代码并不完全适用于现在的情况。OOP设计思想中类的继承相比来说...
详解C++基础——类继承中方法重载
08-26
C++ 基础知识点 —— 类继承中方法重载 在 C++ 编程语言中，类继承是指在已有的类基础上创建新的类，新类继承了原来类的成员变量和成员函数。然而，在继承的过程中，我们需要注意到方法重载的概念。方法重载...
c与c++关键字的用法总结
dreamhighiy的专栏
07-08 610
/* 1，关键字的总结 register: （1），这个关键字请求编译器尽可能的将变量存在CPU内部寄存器中，而不是通过内存寻址访问，以提高效率。 （2），register定义的变量：register int num=10；不能对其取地址。即不能：int *p=&num. const: (1),const修饰变量，以下两种定义形式在本质上是一样的。它的含义是：const修饰的类型为TY
继承
熊猫拿铁
11-23 129
1. 继承 1.1 继承的实现 继承的概念 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法 实现继承的格式 继承通过extends实现 格式：class 子类 extends 父类 { } 举例：class Dog extends Animal { } 继承带来的好处 继承可以让类与类之间产生关系，子父类关系，产...
C++继承特性
weixin_34224941的博客
03-11 121
1. 子类不声明构造函数 #include <iostream> class Uncopyable { public: Uncopyable(); ~Uncopyable() {} Uncopyable(const Uncopyable&); Uncopyable& operator=(const Uncopyable&); }; Uncopy...
详解C++继承（普通继承，菱形继承与虚拟继承）
唐学长的博客
05-05 551
继承的概念 继承的具体操作 继承的格式 友元与静态成员的继承 菱形继承与虚拟继承
Extend-KMP C++ 模板
weixin_34228387的博客
11-22 73
#include <iostream> using namespace std; /************************************************************************/ /* Name: GetExtendNext /* Description: Get Next Array /* Parameter Li...
extendGcd,即扩展欧几里得算法的C++模板化解释
...
07-21 2536
刚刚接触感觉很高大上的“扩展欧几里得算法“，很郁闷，研究了很久。现在感觉能够套模板了，当然这样是远远不够的，不过先写篇博客记录一下最近的动态。帮助自己记忆，也可以帮助大家理解下这个数学算法，当然欢迎各位的斧正和指点，我将不断努力！        首先，明确我们要求ax+by=c中x,y的整数解（至于没有解的情况下边会讨论）        大家应该看到过ax+by=Gcd(a,b)的式子，现在我
C++——图书管理系统课程设计
09-26
它的核心特性包括类（class）、封装、继承、多态性等，这些都是实现图书管理系统的关键。 在设计图书管理系统时，我们首先需要定义几个关键的数据结构，如书籍（Book）、读者（Reader）和借阅记录（BorrowRecord）...
<C extends T>
任香980101
12-08 155
&lt;C extends T&gt; 是限制 Class&lt;C&gt;里的C的 也就是C需要是T的实现类或者子类 泛型更具体 public static class abc&lt;E extends  CharSequence&gt;{            public E e;            public abc(E o){             ...
实现 extend 函数
初漾的博客
06-18 2662
浅拷贝使用 Object.assign 就够了，大多数情况下，使用该方法。 深拷贝: (参考: zepto extend) var class2type = {} function type(obj) { return obj == null ? String(obj) : class2type[toString.call(obj)] || "object" } funct
从0开撸C++（三）——继承和多态特性
weixin_37620587的博客
09-19 228
从0开撸C++系列 往期地址： c++的封装 c++的继承 本期主题： c++中的继承与多态特性 // 1.继承体系下的构造/析构函数关系 2.子类和父类的类型兼容 3.多继承 3.1 多继承的二义性问题 3.2 用虚继承来解决二义性问题（注意虚继承与虚函数不同） 4.多态 4.1多态的概念 4.2 虚函数 文章目录从0开撸C++系列1.继承体系下的构造/析构函数关系2.不同类型的继承2.1 public继承2.2 private继承2.3 protected继承3.关于继承的总结 1.继承体系下的
extend()方法
weixin_30763397的博客
12-25 1523
extend()方法 描述 列表extend() 方法通过在列表末尾追加可迭代对象中的元素来扩展列表。 语法 extend() 方法语法： L.extend(iterable) 参数 iterable -- 可迭代对象（字符串、列表、元祖、字典）。 返回值 该方法没有返回值，但会在原来的列表末尾追加可迭代对象中的元素。 实例 L = ['Google',...
c++ 合并string_extend、深浅合并、深浅克隆 | 继续扩展utils.js | 跟着jQuery大佬学编程思想...
weixin_28909295的博客
12-26 401
▲ 点击上方蓝字关注我▲文 / 景朝霞来源公号 / 朝霞的光影笔记ID / zhaoxiajingjing目录：0 / extend的应用1 / 简单实现extend方法2 / 应用：深浅比较的对象合并3 / 对象的深浅合并(1)浅合并 shallowMerge(2)深合并 deepMerge(3)优化深合并4 / 深浅克隆(1)浅克隆 shallowClone(2)深克隆 deepC...
c++多线程 二
extend_die的专栏
10-30 484
引言 C++11 是 2011 年 9 月 1 号发布的。C++11 在 C++03 的基础上做了大量的改进，引入了很多新的特性，比如 Lambda 表达式，右值引用，统一的列表初始化方式，正则表达式等等。当然，其中最令人激动的特性是新标准引入了原子操作类和线程支持库。C++ 一直在语言层面缺少对多线程的支持，因此 C++11 新标准基本上弥补了这一缺陷。可以毫不夸张地说，C++11 相当于
C++-继承
AI_ELF的博客
02-13 1484
C++-继承继承继承关系和访问限定符继承基类成员访问方式的变化 继承 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承是类设计层次的复用。 继承的定义： #define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> using namespace std; cl
C++ 继承 (inheritance)
我是小白呀的博客
05-12 5285
C++ 继承. 继承 & 类的概念. 继承的重要性以及如何实现.
关键字之extends
qq_36117744的博客
01-27 501
extends:继承 什么是继承呢,这个可以说是java的基础了,继承都不知道的兄弟可以回家种田去了,(碎碎念,碎碎念.....) 已有的类能被继承 已有的抽象类能被继承,(继承了抽象类需要把抽象类里的抽象方法abstract全部实现) 接口不能被继承(只能被实现,其实和继承差不多,但是要实现所有接口里的方法,可以一个类实现多个接口,类似多继承)  父类和子类之间的关系 子类可以...
C++进阶 —— 继承
NapoleonCoder的博客
12-04 779
继承、基类与派生类，菱形继承、虚拟继承！
实训C++语言设计——Student学生类设计、继承、重写
最新发布
05-29
好的，我会尽力回答你的问题。首先，我们来设计一个 Student 学生类，包括以下属性： - 学号（id） - 姓名（name） - 年龄（age） - 性别（gender） - 成绩（score） 首先，我们可以定义一个 Student 类，如下所示： ```cpp class Student { public: int id; string name; int age; string gender; double score; }; ``` 接下来，我们可以通过继承来创建一个更具体的类，比如说 Undergraduate 本科生类。我们可以从 Student 类中继承属性，并添加一些新的属性和方法，如下所示： ```cpp class Undergraduate : public Student { public: string major; int year; void display() { cout << "ID: " << id << endl; cout << "Name: " << name << endl; cout << "Age: " << age << endl; cout << "Gender: " << gender << endl; cout << "Score: " << score << endl; cout << "Major: " << major << endl; cout << "Year: " << year << endl; } }; ``` 在这个例子中，我们使用了 public 继承，使得 Undergraduate 类可以访问 Student 类中的公有成员。我们还定义了一个新的方法 display，用于打印出 Undergraduate 类中的所有属性。 最后，我们可以通过重写父类的方法来定制化 Undergraduate 类的行为。比如说，我们可以重写 Student 类中的 display 方法，如下所示： ```cpp class Undergraduate : public Student { public: string major; int year; void display() { cout << "ID: " << id << endl; cout << "Name: " << name << endl; cout << "Age: " << age << endl; cout << "Gender: " << gender << endl; cout << "Score: " << score << endl; cout << "Major: " << major << endl; cout << "Year: " << year << endl; cout << "This is an undergraduate student." << endl; } }; ``` 在这个例子中，我们重写了 display 方法，添加了一行文本，用于提示这是一个本科生对象。 希望这个例子能够帮助你理解 C++ 中的类设计、继承和重写。如果你有任何其他问题，可以随时问我。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

袁百万

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

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

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

打赏作者

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

抵扣说明：

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

余额充值