C++之子类继承与父类构造

已于 2024-10-19 16:50:44 修改
阅读量1.1k 收藏 22
点赞数 26
分类专栏： C++ 文章标签： c++
于 2024-10-19 16:46:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44914161/article/details/143080496
版权

C++之子类继承与父类构造

文章目录

1.问题引出

笔者最近在阅读godot源码，之前学过一些半吊子的C++，对一些东西知其然不知其所以然，希望在阅读项目源码的过程中思考一些问题。言归正传，在godot的初始启动流程中，有如下代码：

//启动流程 Main.cpp文件下
Main::setup(const char *execpath, int argc, char *argv[], bool p_second_phase)
{
	OS::get_singleton()->initialize();
}

//OS::get_singleton()实现 os.cpp下
OS *OS::singleton = nullptr;
uint64_t OS::target_ticks = 0;

OS *OS::get_singleton() {
	return singleton;
}

上述实现了一个单例模式，返回的是一个在os.cpp文件下的全局变量OS *OS::singleton。该全局变量初始化的时候是一个nullptr，虽然空指针可以调用成员函数，但是这肯定不符合单例模式的设计理念。笔者最终找到了OS *OS::singleton实际赋值的地方：

OS::OS() {
	singleton = this;

	Vector<Logger *> loggers;
	loggers.push_back(memnew(StdLogger));
	_set_logger(memnew(CompositeLogger(loggers)));
}

这里是OS类的构造函数，当实例化一个OS类的时候，就会将实例化对象的指针赋值到singleton指针上。笔者又在启动流程下寻找OS的实例化位置，最终找到代码如下：

OS_LinuxBSD os;

在程序最开始的main函数位置，实例化了os，实例化的类是OS_LinuxBSD，并非OS。阅读代码发现存在以下继承关系，OS_LinuxBSD继承于OS_Unix， OS_Unix继承于OS。
这里引出如下几个思考：

  • 当子类继承父类，实例化子类的时候，父类构造的作用
  • 链式继承的时候，父类构造的作用
  • C++允许多继承，多个父类构造的作用

2.原则

此处部分参考了菜鸟教程，构造原则如下所示：

  • 如果一个子类没有定义自己的构造函数，当实例化对象的时候，调用父类的无参构造方法
  • 如果子类定义了构造函数，不论该构造函数有参还是无参，在实例化子类对象的时候，首先调用父类的无参构造函数，然后执行自己的构造方法
  • 实例化子类对象的时候，如果子类的构造函数没有显式调用父类的构造函数，则会调用父类的默认无参构造函数。
  • 在实例化子类对象的时候，如果子类的构造函数没有显式调用父类的构造函数，且父类自己提供了无参构造函数，则会调用父类自己的无参构造函数。
  • 在实例化子类对象的时候，如果子类的构造函数没有显式调用父类的构造函数且父类只定义了自己的有参构造函数，则会报错；在该情况下，子类必须显示调用有参构造方法。
  • 如果子类调用父类带参数的构造方法，需要用初始化父类成员对象的方式。
    上诉规则其实可以用一个思维导图总结如下：
    在这里插入图片描述

总之：当且仅当父类只有有参构造的时候，需要子类显式调用；如果父类存在无参构造，即使是默认无参，子类对象实例化的时候都会调用无参构造函数。

3.解析

3.1单一继承

3.1.1 父类无参构造函数
3.1.1.1子类无定义构造函数
#include <iostream>
#include <string>

class fruit
{
public:
    int price;
    std::string name;

public:
    //父类无参构造
    fruit()
    {
        std::cout << "class Fruit parameterless constructor" << std::endl;
    }
};

class apple : fruit
{
public:
};



int main()
{
    std::cout << "-----------------------------------------------" << std::endl;
    apple a1;
    std::cout << "-----------------------------------------------" << std::endl;

    return 0;
}

上述代码里实现了父类fruit和子类apple，父类提供了无参构造，子类未实现任何构造函数，此时会默认存在一个无参构造函数，当我们实例化子类对象时，执行结果如下：
在这里插入图片描述

子类对象实例化时会默认调用父类的无参构造函数。

3.1.1.2子类定义构造函数
#include <iostream>
#include <string>

class fruit
{
public:
    int price;
    std::string name;

public:
    //父类无参构造
    fruit()
    {
        std::cout << "class Fruit parameterless constructor" << std::endl;
    }
};

class apple : fruit
{
public:
	//子类无参构造
    apple()
    {
        std::cout << "class Apple parameterless constructor" << std::endl;
    }
    //子类有参构造
    apple(int price)
    {
        this->price = price;
        std::cout << "the price is: " << this->price << std::endl;
    }
    
};


int main()
{
    std::cout << "-----------------------------------------------" << std::endl;
    apple a1;
    std::cout << "-----------------------------------------------" << std::endl;
    apple a2(10);
    std::cout << "-----------------------------------------------" << std::endl;
    return 0;
}

父类是fruit，子类是apple，父类实现了无参构造，子类实现了无参构造和有参构造，同时没有显式调用父类构造函数。
执行结果如下：
在这里插入图片描述

从执行结果来看，不管是子类的无参构造函数还是有参构造函数，都会首先调用父类的无参构造函数。
如果我们没有定义父类无参构造呢，实际上也会存在一个默认无参构造，它不做任何事情。

3.1.2 父类存在无参构造函数和有参构造函数
#include <iostream>
#include <string>

class fruit
{
public:
    int price;
    std::string name;

public:
    //父类无参构造
    fruit()
    {
        std::cout << "class Fruit parameterless constructor" << std::endl;
    }
    fruit(int price)
    {
        this->price = price;
        std::cout << "[fruit] the price is: " << this->price << std::endl;
    }
};

class apple : fruit
{
public:
	//子类无参构造
    apple()
    {
        std::cout << "class Apple parameterless constructor" << std::endl;
    }
    //子类有参构造
    apple(int price)
    {
        this->price = price;
        std::cout << "[apple] the price is: " << this->price << std::endl;
    }
    
};



int main()
{
    std::cout << "-----------------------------------------------" << std::endl;
    apple a1;
    std::cout << "-----------------------------------------------" << std::endl;
    apple a2(10);
    std::cout << "-----------------------------------------------" << std::endl;
    return 0;
}

修改后的代码如上所示，我们为fruit类实现了一个有参构造函数，依旧实例化两个子类对象，一个无参，一个有参，执行结果如下所示：
在这里插入图片描述

在子类没有显式调用的情况下，都会默认首先调用父类的无参构造，让后执行自己的对应的构造函数里的内容。

3.1.3 父类仅存在有参构造函数
#include <iostream>
#include <string>

class fruit
{
public:
    int price;
    std::string name;

public:
    //父类无参构造
    /*fruit()
    {
        std::cout << "class Fruit parameterless constructor" << std::endl;
    }*/
    fruit(int price)
    {
        this->price = price;
        std::cout << "[fruit] the price is: " << this->price << std::endl;
    }
};

class apple : fruit
{
public:
	//子类无参构造
    apple()
    {
        std::cout << "class Apple parameterless constructor" << std::endl;
    }
    //子类有参构造
    apple(int price)
    {
        this->price = price;
        std::cout << "[apple] the price is: " << this->price << std::endl;
    }
    
};



int main()
{
    std::cout << "-----------------------------------------------" << std::endl;
    apple a1;
    std::cout << "-----------------------------------------------" << std::endl;
    apple a2(10);
    std::cout << "-----------------------------------------------" << std::endl;
    return 0;
}

注释掉父类的无参构造对象，子类无显式调用，编译，结果如下：
在这里插入图片描述

编译器会报错，指明没有匹配的函数调用。
我们将子类构造修改为显式调用，因为无参构造函数没有参数提供，我们这里给一个默认参数：

#include <iostream>
#include <string>

class fruit
{
public:
    int price;
    std::string name;

public:
    //父类无参构造
    /*fruit()
    {
        std::cout << "class Fruit parameterless constructor" << std::endl;
    }*/
    fruit(int price)
    {
        this->price = price;
        std::cout << "[fruit] the price is: " << this->price << std::endl;
    }
};

class apple : fruit
{
public:
	//子类无参构造
    apple():fruit(15)
    {
        std::cout << "class Apple parameterless constructor" << std::endl;
    }
    //子类有参构造
    apple(int price):fruit(price)
    {
        this->price = price;
        std::cout << "[apple] the price is: " << this->price << std::endl;
    }
    
};



int main()
{
    std::cout << "-----------------------------------------------" << std::endl;
    apple a1;
    std::cout << "-----------------------------------------------" << std::endl;
    apple a2(10);
    std::cout << "-----------------------------------------------" << std::endl;
    return 0;
}

对于子类来说，想要显式调用父类构造，只要在对应的构造函数后加上冒号然后使用父类构造函数即可。我们将子类的默认无参构造函数的调用参数设置为15，在实例化a2的时候，使用的还是子类有参构造函数里的参数，执行结果如下所示：
在这里插入图片描述

我们看到两个实例化对象都会调用对应的父类有参构造函数，同时使用子类无参构造的实例化对象的价格，也被设置为了子类无参构造函数调用父类有参构造函数时的参数。

3.2链式继承

我们基本理清楚了一件事情，如果父类存在无参构造函数，那么子类不显式调用时，会默认首先调用父类无参构造；如果父类不存在无参构造，则子类必须显式调用父类有参构造，否则编译器会编译不过。接下来我们将场景设置复杂一点，设置一个链式继承关系，就像我开头的案例一样，代码如下：

#include <iostream>
#include <string>

class fruit
{
public:
    int price;
    std::string name;

public:
    //父类无参构造
    fruit()
    {
        std::cout << "class Fruit parameterless constructor" << std::endl;
    }
    fruit(int price)
    {
        this->price = price;
        std::cout << "[fruit] the price is: " << this->price << std::endl;
    }
};

class apple : public fruit
{
public:
	//子类无参构造
    apple()
    {
        std::cout << "class Apple parameterless constructor" << std::endl;
    }
    //子类有参构造
    apple(int price):fruit(price)
    {
        this->price = price;
        std::cout << "[apple] the price is: " << this->price << std::endl;
    }
    
};

class green_apple : public apple
{
public:
    green_apple()
    {
        std::cout << "class green_Apple parameterless constructor" << std::endl;
    }
    green_apple(int price):apple(price)
    {
        std::cout << "[green_Apple] the price is: " << this->price << std::endl;
    }
};



int main()
{
    std::cout << "-----------------------------------------------" << std::endl;
    green_apple a1;
    std::cout << "-----------------------------------------------" << std::endl;
    green_apple a2(10);
    std::cout << "-----------------------------------------------" << std::endl;
    return 0;
}

我们定义了第三个类型green_apple继承于apple，分别实现了有参和无参构造，最后在实例化的时候分别实现了无参和有参的实例化，执行结果如下：
在这里插入图片描述

显而易见，会最先调用最基类的构造函数，之后逐层调用。其实按照理解来说，应该可以说是不显式调用的时候，会自动塞一个父类无参构造函数给子类构造函数，如果父类没有无参构造，对于编译器来说，就不知道如何去放置有参构造函数了，所以需要我们显式调用，自己去指定调用哪一个父类构造函数。当子类调用构造函数时，会先调用父类的构造函数，当父类也继承于另一个类时，父类构造又会先调用另一个类的构造，逐层递归，最终表现为最先调用最基类的构造函数。

3.3多继承

基于前面的分析，我们其实已经可以推测出来多继承的逻辑了，其一定是按照顺序分别调用父类的构造函数，设计代码如下：

#include <iostream>
#include <string>

class fruit
{
public:
    int price;
    std::string name;

public:
    //父类无参构造
    fruit()
    {
        std::cout << "class Fruit parameterless constructor" << std::endl;
    }
    fruit(int price)
    {
        this->price = price;
        std::cout << "[fruit] the price is: " << this->price << std::endl;
    }
};

class season
{

public:
    //父类无参构造
    season()
    {
        std::cout << "class season parameterless constructor" << std::endl;
    }
};

class apple : public fruit, public season
{
public:
	//子类无参构造
    apple()
    {
        std::cout << "class Apple parameterless constructor" << std::endl;
    }
    //子类有参构造
    apple(int price):fruit(price)
    {
        this->price = price;
        std::cout << "[apple] the price is: " << this->price << std::endl;
    }
    
};



int main()
{
    std::cout << "-----------------------------------------------" << std::endl;
    apple a1;
    std::cout << "-----------------------------------------------" << std::endl;
    apple a2(10);
    std::cout << "-----------------------------------------------" << std::endl;
    return 0;
}

实现了另一个父类season，apple同时继承于fruit和season，代码执行结果如下：
在这里插入图片描述

无参实例化对象分别调用了fruit和season的无参构造函数。有参实例化对象先显式调用了fruit的有参构造函数，之后调用了season的无参构造函数，最后执行自己的有参构造函数部分。

4.结论

  • 子类会在构造函数中默认调用父类的无参构造函数
  • 父类不存在无参构造函数时，子类需要指定调用的父类有参构造函数
  • 链式继承时会先调用父类的构造函数，如果父类还存在父类，则父类构造会先调用父类的父类的构造函数，依此递归，最终的结果是按照辈分逐级执行构造
  • 多继承时按照继承顺序逐步调用父类构造函数

5.回到开头

由此回答我开头引入的问题，OS_LinuxBSD创建时调用了父类的父类OS的无参构造函数，将单例的指针设置为了自己。

子类如何继承父类的构造函数？
破损的天堂鸟博客
07-12 901
首先，在子类的构造函数中，通过初始化列表来调用父类的构造函数。初始化列表以一个冒号（:）开始，然后是数据成员列表，每个数据成员后面跟一个放在括号中的初始化式。
C++那.事，继承、多重继承、调用父类带参构造函数。
weixin_43897371的博客
04-04 622
1、继承 继承方式 随便定义一个类 class people { private : int i; protected: int j; public: int k; public : people() { i = 1; j = 2; k = 3; } public : void display() { cout<<i<<endl;...
c++ 子类父类构造函数
gcclife的专栏
12-16 5989
转 http://tieba.baidu.com/f?kz=1167962877  1楼 这两天一直搞不明白C++继承的构造函数该怎么写。现在经过实验，总结出了一些观点。欢迎大家批评指正。 在继承中， 一，父类没有写出构造函数， 子类的构造函数可以写成“任何”形式而不用顾及父类的构造函数。 例如：父类为CA，子类为CB，父类中没有写出任何构造函数，则子类中可以不写构造函数，或者构造函
C++类继承之子类调用父类的构造函数的实例详解
08-29
主要介绍了C++类继承之子类调用父类的构造函数的实例详解的相关资料,希望通过本文大家能够掌握C++类继承的相关知识，需要的朋友可以参考下
c++构造函数
qq_27357649的博客
11-27 472
构造方法用来初始化类的对象，与父类的其它成员不同，它不能被子类继承（子类可以继承父类所有的成员变量和成员方法，但不继承父类的构造方法）。因此，在创建子类对象时，为了初始化从父类继承来的数据成员，系统需要调用其父类的构造方法。     如果没有显式的构造函数，编译器会给一个默认的构造函数，并且该默认的构造函数仅仅在没有显式地声明构造函数情况下创建。 构造原则如下：     1. 如果子类没有定...
【C++】继承构造函数
Hi, Boy
05-04 1152
【代码】【C++】继承构造函数。
C++类继承:子类调用父类的构造函数
rocklee的专栏
07-14 1603
父类HttpUtil: #pragma once #include #include using namespace std; class HttpUtil { private: LPVOID hInternet; LPVOID hConnect; LPVOID hRequest; protected: wchar_t * mHostName; short mPort;
C++类（构造函数和析构函数、子类继承和调用父类的构造方法）
weixin_44572041的博客
06-06 3508
为什么要有构造、析构函数 类的数据成员不能在类的声明时候初始化，为了解决这个问题，使用构造函数处理对对象的初始化。构造函数是一种特殊的成员函数，与其他函数不同，不需要用户调用它，而是创建对象的时候自动调用。析构函数是对象不再使用的时候，需要清理资源的时候调用。 为什么类的数据成员不能在类的声明时候初始化？ 此处留疑。 我觉得他跟结构体的性质应该是一样的，哈哈。 构造函数 构造函数的调用：一般情况下...
c++ 子类构造函数初始化及父类构造初始化的使用
08-18
在 C++ 中，子类构造函数的初始化涉及到父类构造函数的调用，否则将无法正确地初始化从父类继承来的成员变量。本文将详细介绍 C++ 子类构造函数初始化及父类构造初始化的使用。 首先，我们需要了解构造函数的基本...
在C++中子类继承和调用父类的构造函数方法
01-21
构造方法用来初始化类的对象，与父类的其它成员不同，它不能被子类继承（子类可以继承父类所有的成员变量和成员方法，但不继承父类的构造方法）。因此，在创建子类对象时，为了初始化从父类继承来的数据成员，系统...
C++通过父类构造子类
[PE]经典八炮的博客
11-06 4791
今天我看到这么一句话： 派生类的成员只能通过派生类对象访问基类的保护成员，派生类对一个基类对象中的受保护成员没有访问权限。 也就是说，如果有以下代码： class A { protected: int i; }; class B :public A { B(const A& a) { this->i = a.i; } }; 是无法编译通过的，因为子类B的构造函数无法通过参数a来访问A类的i成员。 那么，怎么通过父类来构造子类呢？在C++11中，加入了一个新的东西，叫类的初始
继承-子父类中的构造函数
qq_42024935的博客
07-21 157
在子类构造对象时，发现，访问子类构造函数时，父类也运行了。 原因：在子类的构造函数中第一行有一个默认的隐式语句super(); 子类的实例化过程：子类所有的构造函数默认都会访问父类中空参数的构造函数。 class Fu { Fu() { System.out.println("fu run"); } } class Zi extends Fu { Zi() { //sup...
C++继承
lzf的博客
07-24 217
C++继承
C++中的继承类构造函数
lzbzclz的博客
03-24 1500
C++中的继承类构造函数注意事项 构造原则如下： 1. 如果子类没有定义构造方法，则调用父类的无参数的构造方法。 2. 如果子类定义了构造方法，不论是无参数还是带参数，在创建子类的对象的时候,首先执行父类无参数的构造方法，然后执行自己的构造方法。 3. 在创建子类对象时候，如果子类的构造函数没有显示调用父类的构造函数，则会调用父类的默认无参构造函数。 4. 在创建子类对象时候，如果子类的构造...
C++——继承
最新发布
头秃中。。。。。
10-30 2515
面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为，新建的类称为。
C++ 给父类带参构造函数的赋值
wendyWJGU的博客
01-06 730
C++ 给父类带参构造函数的赋值
C++父类的构造函数
weixin_45646929的博客
09-22 1426
子类的构造函数默认会调用父类的无参构造函数 如果子类的构造函数显式的调用了父类的有参构造函数，就不会再去默认调用父类的无参构造函数 如果父类缺少无参构造函数，子类的构造函数必须显式调用父类的有参构造函数 #include<iostream> using namespace std; class Person{ int m_age; public: Person(int age) :m_age(age) {} }; class Student :Person{ int m_no;..
cpp——类——构造函数
mardax的专栏
02-13 3407
概述 为了类的使用方便，类的设计尽可能使类的使用方式与内置类型无区别，构造函数则是类模仿内置类型的初始化 内置类型初始化支持直接初始化，复制初始化，默认初始化，构造函数对应于内置类型的各种初始化： 带参数构造函数——直接初始化 复制构造函数——复制初始化 默认构造函数——默认初始化 构造函数特点： 函数名与类名同名，用来标记和识别构造函数 没有返回值，构造函数是对自身的初始化，返回值无意义，因为没有返回值的接收者 初始化行为，构造函数在生成(定义)对象时自动调用，因此构造函数只能执行一次，否则就多次初始化
c++ 子类继承父类构造函数
05-02
子类继承父类构造函数的语法如下： ```c++ class Parent { public: Parent(int a) : m_a(a) {} private: int m_a; }; class Child : public Parent { public: using Parent::Parent; // 继承父类构造函数 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值