多层继承中常见问题

最新推荐文章于 2024-06-19 14:25:46 发布
最新推荐文章于 2024-06-19 14:25:46 发布
阅读量36 收藏
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63282188/article/details/131197166
版权

目录

一、派生类的构造函数问题

1.派生类构造函数不明确指出调用基类构造函数

 二、派生对象的拷贝构造问题

1.基类和派生类都无自定义拷贝构造函数

 2.基类有自定义拷贝构造函数，而派生类没有

3.派生类有自定义拷贝构造函数，基类没有

4. 派生类有自定义拷贝构造函数，基类也有

三、派生对象的拷贝赋值函数问题 

1.都没有拷贝赋值函数

2.基类有，派生类没有

 3.派生类有，基类没有

4.都有拷贝赋值函数

一、派生类的构造函数问题

1.派生类构造函数不明确指出调用基类构造函数

如：

class Int
{
private:
    int value;
public:

    Int(int x = 1) : value{ 1 } {
        cout << "Create Int : " << this << endl;
    }
    ~Int() 
    { cout << "Destroy Int: " << this << endl; 
    }
    Int(const Int& it) :value(it.value) {
        cout << "Copy Create Int " << this << endl;
    }  
    void Print() const {
        cout <<"Int:: "<< value << endl;
    }
};
class Object: public Int
{
private:
    int xval;
public:
    Object(int x = 0) :xval(x + 10) {  //未显示调用基类构造函数
        cout << "Creat Object " << endl;
    }
    ~Object()
    {
        cout << "Destory Object " << endl;
    }
    void Print() const
    {
        Int::Print();
        cout << "Object:: " << xval << endl;
    }
};
int main()
{
    
    Object obj;
    obj.Print();
}

此时,创建派生类对象时，编译器会自动调用基类的缺省构造函数，进行构建基类对象。

 

基类Int中的value 为默认值1；

当基类无缺省构造函数时，此时编译器无法给出匹配的构造函数，会报错，无法编译通过；

 二、派生对象的拷贝构造问题

1.基类和派生类都无自定义拷贝构造函数

如：

class Int
{
private:
    int value;
public:

    Int(int x = 2) : value{ x } {
        cout << "Create Int : " << this << endl;
    }
    ~Int() 
    { cout << "Destroy Int: " << this << endl; 
    }
    void Print() const {
        cout <<"Int:: "<< value << endl;
    }
};
class Object: public Int
{
private:
    int xval;
public:
    Object(int x = 0) : Int(x+1) , xval(x + 10) {
        cout << "Creat Object " << endl;
    }
    ~Object()
    {
        cout << "Destory Object " << endl;
    }
    void Print() const
    {
        Int::Print();
        cout << "Object:: " << xval << endl;
    }
};
int main()
{
    
    Object obj;
    Object s1(obj);
    obj.Print();
    s1.Print();
}

当类中无自定义的拷贝构造函数时，系统会给出默认的缺省构造函数（按位复制） 

进行  Object s1(obj);时,系统会自动调用基类和派生类的默认缺省函数，所以可以正常拷贝赋值。

 2.基类有自定义拷贝构造函数，而派生类没有

如：

class Int
{
private:
    int value;
public:

    Int(int x = 1) : value{ x } {    }
    ~Int()     {     }
    Int(const Int& it) :value(it.value) {
        cout << "Copy Create Int " << this << endl;
    }
    void Print() const {
        cout <<"Int:: "<< value << endl;
    }
};
class Object: public Int
{
private:
    int xval;
public:
    Object(int x = 0) :Int(x),xval(x + 10) {    }
    ~Object()    {    }
    void Print() const
    {
        Int::Print();
        cout << "Object:: " << xval << endl;
    }
};
int main()
{
    
    Object obj;
    Object s1(obj);
    obj.Print();
    s1.Print();
}

进行  Object s1(obj);操作，系统会调用派生类的默认缺省拷贝构造函数，并且调用基类自定义拷贝构造函数，可以成功进行拷贝。

3.派生类有自定义拷贝构造函数，基类没有

如：

 

class Int
{
private:
    int value;
public:

    Int(int x = 1) : value{ x } {    }
    ~Int()     {     }
    void Print() const {
        cout <<"Int:: "<< value << endl;
    }
};
class Object: public Int
{
private:
    int xval;
public:
    Object(int x = 0) :Int(x),xval(x + 10) {    }
    ~Object()    {    }
    Object(const Object& s): xval { s.xval }
    {
        cout << "Copy Create Object" << this << endl;
    }
    void Print() const
    {
        Int::Print();
        cout << "Object:: " << xval << endl;
    }
};
int main()
{
    Object obj;
    Object s1(obj);
    obj.Print();
    s1.Print();
}

 此时 Object s1(obj)操作只会调用派生类自定义拷贝构造函数，不会调动基类默认缺省拷贝构造函数，因为在派生类拷贝构造函数中没有明确指出调用，系统会调用基类默认缺省构造函数构建基类对象。

4. 派生类有自定义拷贝构造函数，基类也有

 如：

class Int
{
private:
    int value;
public:

    Int(int x = 1) : value{ x } {    }
    ~Int()     {     }
    Int(const Int& it) :value(it.value) {
        cout << "Copy Create Int " << this << endl;
    } 
    void Print() const {
        cout <<"Int:: "<< value << endl;
    }
};
class Object: public Int
{
private:
    int xval;
public:
    Object(int x = 0) :Int(x),xval(x + 10) {    }
    ~Object()    {    }
    Object(const Object& s): xval { s.xval }
    {
        cout << "Copy Create Object" << this << endl;
    }
    void Print() const
    {
        Int::Print();
        cout << "Object:: " << xval << endl;
    }
};
int main()
{
    
    Object obj;
    Object s1(obj);
    obj.Print();
    s1.Print();
}

 此情况和4相同，只会调用派生类自定义拷贝构造函数，不会调动基类默认缺省拷贝构造函数，因为在派生类拷贝构造函数中没有明确指出调用，系统会调用基类默认缺省构造函数构建基类对象。

 

此时要想正确进行拷贝，则需要在派生类的拷贝构造函数中明确指出调用基类拷贝构造函数

如：

class Int
{
private:
    int value;
public:

    Int(int x = 1) : value{ x } {    }
    ~Int()     {     }
    Int(const Int& it) :value(it.value) {
        cout << "Copy Create Int " << this << endl;
    } 
    void Print() const {
        cout <<"Int:: "<< value << endl;
    }
};
class Object: public Int
{
private:
    int xval;
public:
    Object(int x = 0) :Int(x),xval(x + 10) {    }
    ~Object()    {    }
    Object(const Object& s) : Int(s), xval { s.xval }
    {
        cout << "Copy Create Object" << this << endl;
    }
    void Print() const
    {
        Int::Print();
        cout << "Object:: " << xval << endl;
    }
};
int main()
{
    
    Object obj;
    Object s1(obj);
    obj.Print();
    s1.Print();
}

此时，便可以成功拷贝。

 

三、派生对象的拷贝赋值函数问题 

1.都没有拷贝赋值函数

如：

class Int
{
private:
    int value;
public:

    Int(int x = 1) : value{ x } {    }
    ~Int()     {     }
   
    void Print() const {
        cout <<"Int:: "<< value << endl;
    }
};
class Object: public Int
{
private:
    int xval;
public:
    Object(int x = 0) :Int(x),xval(x + 10) {    }
    ~Object()    {    }
  
    void Print() const
    {
        Int::Print();
        cout << "Object:: " << xval << endl;
    }
};
int main()
{ 
    Object obj;
    Object s1(66);
    obj = s1;
    obj.Print();
    s1.Print();
}

可以成功赋值；

 

2.基类有，派生类没有

如：

 

class Int
{
private:
    int value;
public:

    Int(int x = 1) : value{ x } {    }
    ~Int()     {     }
    Int& operator=(const Int& s)
    {
        if (&s != this)
        {
            this->value = s.value;
        }

   cout<<"Int::operator=() "<<endl;
        return *this;
    }
    void Print() const {
        cout <<"Int:: "<< value << endl;
    }
};
class Object: public Int
{
private:
    int xval;
public:
    Object(int x = 0) :Int(x),xval(x + 10) {    }
    ~Object()    {    }
  
    void Print() const
    {
        Int::Print();
        cout << "Object:: " << xval << endl;
    }
};
int main()
{ 
    Object obj;
    Object s1(66);
    obj = s1;
    obj.Print();
    s1.Print();
}

 可以成功赋值；

 3.派生类有，基类没有

如：

class Int
{
private:
    int value;
public:

    Int(int x = 1) : value{ x } {    }
    ~Int()     {     }
   
    void Print() const {
        cout <<"Int:: "<< value << endl;
    }
};
class Object: public Int
{
private:
    int xval;
public:
    Object(int x = 0) :Int(x),xval(x + 10) {    }
    ~Object()    {    }
  Object& operator=(const Object& s)
    {
        if (&s != this)
        {
            this->xval = s.xval;
        }
        cout<<"Object:: operator "<<endl;
        return *this;
     }
    void Print() const
    {
        Int::Print();
        cout << "Object:: " << xval << endl;
    }
};
int main()
{ 
    Object obj;
    Object s1(66);
    obj = s1;
    obj.Print();
    s1.Print();
}

不能成功赋值

4.都有拷贝赋值函数

如：

class Int
{
private:
    int value;
public:

    Int(int x = 1) : value{ x } {    }
    ~Int()     {     }
     Int& operator=(const Int& s)
    {
        if (&s != this)
        {
            this->value = s.value;
        }
        cout<<"Int::operator=() "<<endl;
        return *this;
    } 
    void Print() const {
        cout <<"Int:: "<< value << endl;
    }
};
class Object: public Int
{
private:
    int xval;
public:
    Object(int x = 0) :Int(x),xval(x + 10) {    }
    ~Object()    {    }
    Object& operator=(const Object& s)
    {
        if (&s != this)
        {
            this->xval = s.xval;
        }
        cout<<"Object:: operator "<<endl;
        return *this;
     } 
    void Print() const
    {
        Int::Print();
        cout << "Object:: " << xval << endl;
    }
};
int main()
{ 
    Object obj;
    Object s1(66);
    obj = s1;
    obj.Print();
    s1.Print();
}

 

 

没有显式调用基类拷贝赋值函数，不能成功赋值

解决方法：在派生类的拷贝赋值函数中显式调用基类拷贝赋值函数

如：

class Int
{
private:
    int value;
public:

    Int(int x = 1) : value{ x } {    }
    ~Int()     {     }
     Int& operator=(const Int& s)
    {
        if (&s != this)
        {
            this->value = s.value;
        }
        cout<<"Int::operator=() "<<endl;
        return *this;
    } 
    void Print() const {
        cout <<"Int:: "<< value << endl;
    }
};
class Object: public Int
{
private:
    int xval;
public:
    Object(int x = 0) :Int(x),xval(x + 10) {    }
    ~Object()    {    }
    Object& operator=(const Object& s)
    {
        if (&s != this)
        {
            //operator=(s);  错误写法，会无限递归
            Int::operator=(s);
            this->xval = s.xval;
        }
        cout<<"Object:: operator "<<endl;
        return *this;
     } 
    void Print() const
    {
        Int::Print();
        cout << "Object:: " << xval << endl;
    }
};
int main()
{ 
    Object obj;
    Object s1(66);
    obj = s1;
    obj.Print();
    s1.Print();
}

 

 

 

 

槐夏风清7
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程常见问题及分析
LanBuff的博客
03-01 1万+
1、多线程的并发性和多线程介绍：在过去单CPU时代，单任务在一个时间点只能执行单一程序。之后发展到多任务阶段，计算机能在同一时间点并行执行多任务或多进程。虽然并不是真正意义上的“同一时间点”，而是多个任务或进程共享一个CPU，并交由操作系统来完成多任务间对CPU的运行切换，以使得每个任务都有机会获得一定的时间片运行。随着多任务对软件开发者带来的新挑战，程序不在能假设独占所有的CPU时间、所有的内存...
C++继承介绍及使用方法
10-09
继承的另一个重要特性是多层继承，即一个类可以继承自另一个派生类，形成类的继承链。然而，C++只支持单一继承，也就是说，一个类只能有一个直接基类。但是，通过多重继承（多重派生），一个类可以从多个基类中继承...
C++ 继承,多继承，多层继承
qq_40788199的博客
02-19 2151
面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。 当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。 继承代表了is a关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物...
c++ 多层继承分析
半坡居士
02-02 3533
（1）首先我们考虑一个（非虚拟）多重继承的相对简单的例子。看看下面的C++类层次结构: 注意Top被继承了两次（在Eiffel语言中这被称作重复继承）。 这意味着类型Bottom的一个实例bottom将有两个叫做a的元素（分别为bottom.Left::a和bottom.Right::a） 那么Buttom 在内存中是如何存储的呢：编译器建议如下（当然也可以Right放在Left上面...
MiniMall：啥？openFeign接口不能多层继承
上海一九四三
04-24 1559
先来看看这里说的多层继承是啥意思，假设现在有A、B、C三个接口，继承关系如下： public interface A {} public interface B extends A {} public interface C extends B {} C接口通过B间接继承A接口，这种方式上并没有什么毛病吧？而且也很常见。但是如果这个时候，在C接口上加上@FeignClient注解，默认情况下...
本科论文常见答辩问题整理
热门推荐
柒月学习小基地
05-11 2万+
答辩过程中，老师问的问题一般都和你的设计有关，特别是设计中的一些关键技术，比如：数据库链接方式，数据库设计中的ER图、范式等。一般不会太难，都是一些学过的知识。 对自己设计的评价不要绝对化。比如填补什么空白、国内领先、很好、没有什么问题、最优之类的字眼。回答问题时要谦虚、诚恳，态度端正。 下面总结了一下提问的问题给大家： 业务，功能模块，老师对某个模块需要详细了解，问你是怎么做的，其实就是你的代码实现逻辑；功能怎么实现的。 框架，SSM，SSH这些有什么优势。 前端，前端用了什么；无非就是CSS、HTML这
c++面试常见问题总结
qq_26105397的博客
06-05 1万+
近来在面试的过程，发现面试官在c++方面总是喜欢问及的一些相关问题总结，当时没怎么答出来，或者是答的不怎么全面，故而查询相关资料总结下。(后面实际工作会进行实时更新信息) &lt;一&gt;c++虚函数方面 虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承...
从零开始学Python编程之子类、父类和多层继承
岛上程序猿
04-07 1209
在本文中，我们介绍了Python编程中子类、父类和多层继承的概念。我们还讨论了方法重写和多态的概念。希望这篇文章能够帮助你更好地理解Python编程中的继承和多态概念。
Java中常见的设计模式
熊先森的博客
04-19 7588
什么是设计模式？设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设 计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。总共有 23 种设计模式 ， 可以分为三大类 ： 创建型模式 ， 结构型模式 ， 行为型模式 。
python 多重类继承__init__
uncle_ll的博客
03-29 6199
目的 项目中遇到多重类继承的问题，想调用父类构造函数中的内容，调试了一两个小时，遇到两个问题。 说不存在某个父类的函数； 报MRO列表错误； 查询了相关的文档，大致是讲解父类的继承，没有涉及到多重继承，以及多重继承构造函数的问题，这里总结一下。 调用父类方法 想在子类中调用父类的某个已经被覆盖的方法： 解决方案 为了调用父类(超类)的一个方法，可以使用 super() 函数，比如 class ...
JAVA 使用反射获得继承类
OovEver的专栏
11-20 6773
JAVA 使用反射获得继承类一代码完成 首先创建两个类，Parent.class与Children.class，Children类继承Parent类。 package util;/** * Children类 * Created by OovEver on 2017/11/20. */ public class Children extends Parent { public st
解析C++中多层派生时的构造函数及一些特殊形式
09-03
在C++编程语言中，多层派生是一种常见的继承机制，允许一个类（派生类）从另一个派生类（间接基类）继承，而间接基类本身可能已经从一个或多个基类继承。这种继承结构有助于代码复用和创建复杂的类层次结构。在多层...
JavaScript 继承详解（一）
10-29
这种机制使得我们可以实现多层继承，一个对象可以从多个对象中继承属性和方法。 总结起来，JavaScript的继承机制主要依赖于构造函数和原型链。虽然JavaScript没有传统的类，但它通过模拟类的概念和使用原型链实现了...
CSS多层样式.pdf
10-04
在CSS（层叠样式表）中，多重样式是常见的应用场景，这意味着同一个元素可能受到外部样式表、内部样式表和内联样式的共同影响。优先级的确定是理解CSS工作原理的关键，它决定了哪种样式会最终应用到元素上。 首先，...
用最简单的方法判断JavaScript中this的指向(推荐)
10-19
通过掌握上述三个法则，可以更准确地预测和控制`this`的行为，从而避免JavaScript中的常见陷阱。在实际开发中，结合`call`、`apply`和`bind`等方法，可以更灵活地操作`this`，以满足复杂场景的需求。
6.15 c语言
jwh199694的博客
06-15 243
char类型的指针变量称为字符指针变量，字符指针变量与字符有着密切关系，他也被用来处理字符串。当一个字符指针指向一个字符串常量时，不能修改指针指向的对象的值。3、字符串常量//char *p = “welcome”;字符串常量不能被修改，因为存储在静态存储区//会发生段错误。初始化字符指针是把内存中字符串的首地址赋予指针。c语言通过使用字符数组来处理字符串。2、static局部变量。
C的I/O操作
weidl001的博客
06-17 718
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
C语言中的内存分配方式（静态分配、动态分配）定义以及区别
2402_85246552的博客
06-17 273
这种分配方式主要用于局部变量，特别是那些大小在编译时无法确定，或者需要在程序运行时改变大小的变量。：malloc函数用于在堆（heap）上分配指定字节数的内存，并返回一个指向该内存区域的指针。内存分配发生在程序运行时，所以内存大小和生命周期可以在运行时动态改变。内存分配在程序编译时就已经确定，所以内存大小和生命周期都是固定的。静态分配的变量在函数调用时，它们的内存空间会在函数调用栈帧中分配，并在函数返回时释放。动态分配的变量的内存空间在堆上，函数调用时传递的是指针，所以函数调用的开销相对较小。
项目篇：加入Python程序之如何在Python中使用C++？
最新发布
Francis的博客
06-19 242
项目篇：加速Python程序之如何在Python中使用C++？通常像一些耗时的操作，我们期望在C++中去实现，然后使用Python去调用对应的接口，或者因为底层库的原因，需要支持对外的Python API，那么我们通常需要支持在Python中访问C++，如何实现呢？方法比较多，本节以pybind11为例，引入一个完整的项目工程模版，如果你后续有这种需求，可以基于模版去修改。注：(懒人版)本节的所有...
多重继承和多层继承c++
05-19
多层继承是指一个派生类从一个基类中继承的同时，这个基类本身也继承自另一个基类。例如： ``` class Base1 { public: void foo() { cout ; } }; class Base2 : public Base1 { public: void bar() { cout ; } }...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值