7.2 单继承

于 2024-06-25 22:15:50 发布
阅读量652 收藏 24
点赞数 19
分类专栏： 夏驰和徐策带你从零开始学习C++(面向对象的程序设计) 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tang7mj/article/details/139970983
版权

7.2 单继承

前一节讲述了单继承的基本概念。这一节讲述单继承的使用。在单继承中，每个类可以生成多个派生类，但是每个派生类只能有一个基类。派生类中只有一个基类是单继承的主要特点。

7.2.1 派生类构造函数和析构函数

派生类的构造函数和析构函数的构造是重要问题，读者需要掌握它们。

1. 派生类的构造函数

派生类的数据成员包含了基类中的数据成员和派生类中新定义的数据成员。由于构造函数不能被继承，因此，派生类的构造函数必须通过调用基类的构造函数来初始化基类的数据成员。如果派生类中还有子对象，也应包含对子对象初始化的构造函数。

派生类构造函数的一般格式如下：

派生类名(派生类构造函数参数表) : 基类构造函数(参数表1), 子对象名(参数表2) {
    // 派生类中数据成员初始化
}

派生类构造函数的调用顺序如下：

  1. 基类的构造函数
  2. 子对象类的构造函数（如果有）
  3. 派生类构造函数

下面通过一个例子说明派生类构造函数的使用。

[例7.4] 分析下列程序的输出结果
#include <iostream>
using namespace std;

class A {
public:
    A() {
        a = 0;
        cout << "A's default constructor called.\n";
    }
    A(int i) {
        a = i;
        cout << "A's constructor called.\n";
    }
    ~A() {
        cout << "A's destructor called.\n";
    }
    void Print() const {
        cout << a << ",";
    }
    int GetA() {
        return a;
    }
private:
    int a;
};

class B : public A {
public:
    B() {
        cout << "B's default constructor called.\n";
    }
    B(int i, int j, int k) : A(i), aa(j) {
        b = k;
        cout << "B's constructor called.\n";
    }
    ~B() {
        cout << "B's destructor called.\n";
    }
    void Print() {
        A::Print();
        cout << b << ",";
        cout << aa.GetA() << endl;
    }
private:
    int b;
    A aa;
};

int main() {
    B bb[2];
    bb[0] = B(1, 2, 5);
    bb[1] = B(3, 4, 7);
    for(int i = 0; i < 2; i++) {
        bb[i].Print();
    }
    return 0;
}

执行该程序输出结果如下：

A's default constructor called.
A's default constructor called.
B's default constructor called.
A's default constructor called.
A's default constructor called.
B's default constructor called.
A's constructor called.
A's constructor called.
B's constructor called.
B's destructor called.
A's destructor called.
A's destructor called.
A's constructor called.
A's constructor called.
B's constructor called.
B's destructor called.
A's destructor called.
A's destructor called.
1,5,2
3,7,4
B's destructor called.
A's destructor called.
A's destructor called.
B's destructor called.
A's destructor called.
A's destructor called.

说明：

  1. 该程序中，先定义了类A，接着定义类B，它是类A的派生类，继承方式为公有继承。

  2. 派生类B的构造函数格式如下：

    B(int i, int j, int k) : A(i), aa(j) {
    b = k;
    cout << "B's constructor called.\n";
}

    其中，B是派生类构造函数名，它的总参数表中有3个参数：参数i用来初始化基类的数据成员，参数j用来初始化类B中的子对象aa，参数k用来初始化类B中的数据成员b。冒号后面的是成员初始化列表，如果该表有多项，它们之间用逗号分隔。

  3. 对该程序执行后的输出结果作如下分析：

    • 先创建具有两个对象元素的对象数组。调用两次类B的默认构造函数，每调用一次类B的默认构造函数时会调用两次类A的默认构造函数和一次类B的默认构造函数，于是出现了输出结果的前6行。
    • 接着，程序中出现两个赋值语句，即给两个已定义的对象（对象数组元素）赋值。系统要建立一个临时对象，通过调用B类的三个参数的构造函数对它初始化，并将其值赋给左值对象，再调用B类的析构函数将临时对象删除。在B类的析构函数中隐含了基类的析构函数和子对象aa的析构函数，其调用顺序与相应的构造函数相反，结果中出现了两个调用派生类B的构造函数和析构函数的12行输出信息。最后，程序结束前由系统自动调用派生类B的析构函数，显示输出了删除两个对象的6行信息。
2. 派生类的析构函数

当对象被删除时，派生类的析构函数就被执行。由于析构函数也不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数时的顺序正好相反。这一点从前面讲过的例7.4可以看出，请读者自行分析。

下面通过一个简单例子进一步说明析构函数的执行顺序。

[例7.5] 分析下列程序的输出结果
#include <iostream>
using namespace std;

class M {
public:
    M() {
        m1 = m2 = 0;
    }
    M(int i, int j) {
        m1 = i;
        m2 = j;
    }
    void print() {
        cout << m1 << "," << m2 << ",";
    }
    ~M() {
        cout << "M's destructor called.\n";
    }
private:
    int m1, m2;
};

class N : public M {
public:
    N() {
        n = 0;
    }
    N(int i, int j, int k) : M(i, j), n(k) {}
    void print() {
        M::print();
        cout << n << endl;
    }
    ~N() {
        cout << "N's destructor called.\n";
    }
private:
    int n;
};

int main() {
    N n1(5, 6, 7), n2(-2, -3, -4);
    n1.print();
    n2.print();
    return 0;
}

执行该程序输出如下结果：

5,6,7
-2,-3,-4
N's destructor called.
M's destructor called.
N's destructor called.
M's destructor called.

该程序的上述结果请读者自己分析。

3. 派生类构造函数使用中应注意的问题

在实际应用中，派生类构造函数中应该隐含或显式包含基类中的构造函数。派生类的构造函数中需要包含基类的默认构造函数时，派生类构造函数隐含着基类的默认构造函数；派生类的构造函数中需要包含基类的带参数的构造函数时，派生类构造函数显式包含基类的带参数的构造函数。

下面举例说明这一点。

[例7.6] 分析下列程序输出结果
#include <iostream>
using namespace std;

class A {
public:
    A() {
        a = 0;
    }
    A(int i) {
        a = i;
    }
    void print() {
        cout << a << ",";
    }
private:
    int a;
};

class B : public A {
public:
    B() {
        b1 = b2 = 0;
    }
    B(int i) : A(i) {
        b1 = i;
        b2 = 0;
    }
    B(int i, int j, int k) : A(i), b1(j), b2(k) {}
    void print() {
        A::print();
        cout << b1 << "," << b2 << endl;
    }
private:
    int b1, b2;
};

int main() {
    B d1;
    B d2(5);
    B d3(4, 5, 6);
    d1.print();
    d2.print();
    d3.print();
    return 0;
}

执行该程序输出如下结果：

0,0,0
5,5,0
4,5,6

说明：

该程序中，派生类B内定义了三个构造函数，前两个构造函数没有显式地调用基类构造函数，其实它们却隐式地调用了基类A中的默认构造函数，由于不需要任何参数，所以可在派生类的构造函数的定义中省去对它的调用。第三个构造函数显式地调用了基类A中的第二个构造函数。

 

7.2.2 子类型和赋值兼容规则

1. 子类型

子类型用来描述类型之间的一般和特殊的关系。当有一个已知类型S，它至少提供类型T的行为，同时还可以包含自己的行为，这时则称类型S是类型T的子类型。子类型的概念涉及行为共享，即代码重用的问题，与继承有着密切的关系。在继承中，公有继承可以实现子类型。例如：

class A {
public:
    void Print() const {
        cout << "A::Print() called.\n";
    }
};

class B : public A {
public:
    void f() {}
};

类B继承了类A，并且是公有继承方式。因此，可以说类B是类A的一个子类型。类B具备类A中的操作，或者说类A中的操作可以用于类B的对象。

分析下列程序：

void f1(const A& r) {
    r.Print();
}

int main() {
    B b;
    f1(b);
    return 0;
}

执行该程序将会输出如下结果：

A::Print() called.

从这个程序中可以看出，类B的对象b交给了处理类A对象的函数f1()进行处理。这就是说，对类A的对象操作的函数，也可以对类B的对象进行操作。

子类型关系是不可逆的。这就是说，已知B是A的子类型，而认为A也是B的子类型是错误的。或者说，子类型关系是不对称的。因此，公有继承可以实现子类型化。

2. 类型适应

类型适应是指两种类型之间的关系。例如，B类型适应A类型是指B类型的对象能够用于A类型的对象所能使用的场合。前面讲过的派生类的对象可以用于基类对象所能使用的场合，因此派生类适应于基类。同样道理，派生类对象的指针和引用也适应于基类对象的指针和引用。子类型与类型适应是一致的。如果A类型是B类型的子类型，那么B类型必将适应于A类型。

子类型的重要性在于减轻程序员编写程序代码的负担，同时也是提高代码重用率的措施。因为一个函数可以用于某类型的对象，则它也可用于该类型的各个子类型的对象，这样就不必为处理这些子类型的对象去重载该函数。

3. 赋值兼容规则

前面已讲过，类B公有继承类A时，则类B是类A的子类型，并且类B适应于类A。这就是说，类B的对象可以用于类A对象所能使用的场合。

在C++中，赋值兼容规则规定：

  1. 派生类对象可以赋值给基类的对象。
  2. 派生类对象的地址值可以赋值给基类的对象指针。
  3. 派生类对象可以用来给基类对象引用初始化。

使用上述规则时，必须注意两点：

  1. 必须是派生类公有继承基类的条件。
  2. 上述三条规定是不可逆的。
[例7.7] 分析下列程序的输出结果
#include <iostream>
using namespace std;

class A {
public:
    A() {
        a = 0;
    }
    A(int i) {
        a = i;
    }
    void print() {
        cout << a << endl;
    }
    int getA() {
        return a;
    }
private:
    int a;
};

class B : public A {
public:
    B() {
        b = 0;
    }
    B(int i, int j) : A(i), b(j) {}
    void print() {
        A::print();
        cout << b << endl;
    }
private:
    int b;
};

void fun(A& d) {
    cout << d.getA() * 10 << endl;
}

int main() {
    B bb(9, 5);
    A aa(5);
    aa = bb;
    aa.print();

    A *pa = new A(8);
    B *pb = new B(1, 2);
    pa = pb;
    pa->print();

    fun(bb);

    delete pa;
    delete pb;

    return 0;
}

执行该程序输出如下结果：

9
1
90

说明：

  1. 该程序中，类B以公有继承方式继承了类A，则类B是类A的子类型。类B是派生类，类A是基类。类B和类A之间满足赋值兼容规则。

  2. 该程序中有三处用到了赋值兼容规则中的规定。

    1. 在语句 aa = bb; 中，右值是派生类B的对象，左值是基类A的对象。根据赋值兼容规则的第一条，该语句是合法的。请读者上机验证，将上述语句改为 bb = aa; 时，是否出现编译错误。
    2. 在语句 pa = pb; 中，右值是派生类B的对象指针，左值是基类A的对象指针。根据赋值兼容规则的第二条，该语句是合法的。请读者上机验证，将上述语句改为 pb = pa; 时，是否出现编译错误。
    3. 在语句 fun(bb); 中，函数 fun 的实参为类B对象 bb，形参为类A的对象引用。在调用函数 fun 时，需将其实参 bb 传递给形参 d。根据赋值兼容规则第三条，允许将派生类B的对象 bb 给基类A的对象引用 d 初始化。请读者上机验证，将上述函数 fun 的形参改为 B& d，将实参改为 aa 是否出现编译错误。

该程序验证了赋值兼容规则中的三条规定。这三条规定还会在后面的程序中出现，请读者分析。

 

 

 

 

 

 

 

 

 

夏驰和徐策
关注
专栏目录
7.2 继承语法
anbimi8960的博客
04-25 59
---恢复内容开始--- 　　在创建一个类时，这个类总是在继承(Object)，因此，除非已经明确指出要从其他类进行继承，否则就是隐式的在从Java标准根Object继承。 　　在继承过程中，需要先声明"新类与旧类相似"，新类extends旧类，当这么做时，会自动获取基类中的所有方法和字段。 示例： 　　 　　为了继承，一般情况下，都是将所有成员变量全部定义为p...
[ XJTUSE ]JAVA语言基础知识—— 7.2 AWT继承体系与Container容器
weixin_47692652的博客
08-20 441
[ XJTUSE ]JAVA语言基础知识—— 7.2 AWT继承体系与Container容器
C++进阶：继承
yourfriendyo的博客
04-14 4114
继承 面向对象的三大特性：封装、继承、多态。继承在实际中用的也不是太多，但必须能熟练使用。 1. 继承的概念 继承机制是面向对象思想中复用代码的一种手段，它能够在原有类的特性的基础上进行扩展。由此产生新的类，称为派生类，原有类称作基类。继承体现了面向对象设计的层次结构，体现了由简单到复杂的认知过程，不同于面向过程只有函数复用，继承是类的设计层面上的复用。 1.1 继承的定义 对于具有一定联系的一类群体，将其抽象成一类对象后，这些对象必然会具有重复的属性。 比如学校中有学生老师两种群体，他们都是属于人这个
C++中的继承
weixin_57023347的博客
08-27 6182
一.继承的概念及定义 发现问题：当我们编写一个类时，发现这个类与类外一个类的成员变量和成员方法相似，并且具有一定的包含关系时，我们编写的这两个类会有很多相似的地方。 比如： 1.1 继承的概念 继承机制是面向对象程序设计使代码可以复用的重要手段。它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生的类称为派生类。 继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承使类设计层次的复用。 ...
C#图解教程（第四版）Chapter7-7.2访问继承的成员
只会写HelloWorld的专栏
02-26 96
using System; namespace IllustratedCSharp_Chapter7_72_AccessClassMember { class Program { static void Main(string[] args) { // Console.WriteLine("Hello World!"); OtherClass oc = new OtherClass(); .
php7.2特性,整理PHP5.5 ~ PHP7.2 新特性
weixin_35398720的博客
03-26 209
PHP5.5 ~ PHP7.2 新特性整理一、从PHP 5.5.x 移植到 PHP 5.6.x使用表达式定义常量在之前的 PHP 版本中， 必须使用静态值来定义常量，声明属性以及指定函数参数默认值。 现在你可以使用包括数值、字符串字面量以及其他常量在内的数值表达式来 定义常量、声明属性以及设置函数参数默认值。...
php7.2编译参数,PHP7.2 版本性能介绍
weixin_42502811的博客
03-10 219
摘要：本文主要和大家详细介绍PHP7.2 版本性能，希望能帮助大家对PHP7.2有一个更清晰的认识。1. 不向后兼容的变更Core：对于封闭资源来说，gettype()函数将返回resource(closed)，取代之前的unknown type。对于__PHP_Incomplete_Class类对象来说，is_object()函数将返回true。移除对Netware操作系统的支持。array类型...
C++ 中的继承
CZHLNN的博客
04-28 1879
继承1 什么是继承1.1 继承的概念1.2 继承的定义1.2.1 定义格式1.2.2 继承关系和访问限定符1.2.3 继承基类成员访问方式的变化2 基类(父类)对象和派生类(子类)对象之间的赋值转换3 继承中的作用域4 派生类(子类)的默认成员函数5 继承与友元6 继承与静态成员7 复杂的菱形继承以及菱形虚拟继承7.1 单继承7.2 多继承7.3 菱形继承7.3.1 菱形继承的问题7.3.2 如何解决7.3.3 虚拟继承解决数据冗余和二义性的原理8 继承的扩展和总结8.1 继承和组合 1 什么是继承 1.1
【 C++ 】继承
bit_zyx的博客
08-31 1119
目录 1、继承的概念及定义 1.1、继承的概念 1.2、继承的定义 定义格式 继承关系和访问限定符 继承基类成员访问方式的变化 2、基类和派生类对象赋值转换 3、继承中的作用域 4、派生类的默认成员函数 5、继承和友元 6、继承与静态成员 7、继承的方式 7.1、菱形虚拟继承 7.2、菱形虚拟继承的原理 8、继承的总结.........
[Python]继承
emmmm.....
09-07 454
1 继承 1.1 继承的概念 1.2 (拓展)经典类和新式类 1.3 体验继承 2 单继承 3 多继承 4 子类重写父类同名方法和属性 4.1 子类重写父类同名方法和属性 4.2 查看子类继承的父类以及父类间的层级关系 5 子类调用父类的同名方法和属性 5.1 子类调用父类的同名方法和属性 5.2 解释 6 多层继承 7 `super()`调用父类的方法 7.1 通过父类的类名调用 7.2 通过super()调用 7.2.1 方法一 7.2.2 方法二 8 私有权限 8.1 定义私有属性和方法 8.2 获取
Vijeo Citect V7.2中文手册
05-12
### Vijeo Citect V7.2中文手册知识...综上所述，Vijeo Citect V7.2版本在继承原有优点的基础上进行了大量改进和升级，不仅提高了软件的整体性能，还增强了安全性和易用性，为用户提供了一个更加高效、可靠的操作平台。
gvim 7.2 GVIM 7.2
07-31
它继承了Vim的强大功能和高效编辑特性，并且增加了图形用户界面（GUI），使得用户在不熟悉命令行环境的情况下也能轻松操作。Vim是一款历史悠久、高度可定制的文本编辑器，因其高效的操作方式和丰富的插件系统而深受...
思想品德：八下第七单元7.2 《维护财产权》（第2课时）课件（粤教版）.ppt
10-14
《维护财产权》是粤教版八年级下册思想品德课程中的一个重要单元，主要探讨了公民的财产权、财产继承权以及智力成果权等相关法律知识。财产权是公民享有、使用、收益和处分财产的权利，这包括占有权、使用权、收益权...
八年级政治下册 第七单元 我们的文化经济权利 7.2 维护财产权教案粤教版.doc
11-17
本文主要涉及的是中学政治课程中的“维护财产权”这一主题，具体涵盖了公民的财产权利，包括财产所有权、财产继承权以及相关的法律保护。以下是详细的知识点解析： 1. **财产所有权**：财产所有权是公民对其财产...
JavaSE-No.7.2——Java的继承(与组合)
Gujiu的博客
05-15 470
适合初学者的java的继承第二节，（protected关键字，final关键字），一起来学习吧！！
开题报告SpringBoot高校双创竞赛申报与路演管理系统.docx
11-02
毕业设计开题报告
开题报告SpringBoot电影订票系统.docx
11-02
毕业设计开题报告
Flask-0.11.tar.zip
11-02
Flask-0.11.tar.zip
开题报告SpringBoot公益服务平台.docx
最新发布
11-02
毕业设计开题报告
C++继承：访问间接基类成员与继承方式详解
如果基类有多个，称为多重继承，单个基类则是单重继承。在派生类中，同名覆盖指的是定义与基类相同名称的成员，这时会优先访问派生类的版本。 7.3 继承方式 C++提供了三种继承方式：公有继承（public）、私有继承...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

夏驰和徐策

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

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

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

打赏作者

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

抵扣说明：

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

余额充值