C++ 继承 派生类的拷贝构造

已于 2024-08-04 20:06:25 修改
阅读量658 收藏 4
点赞数 13
分类专栏： c语言 c/c++ 文章标签： c++
于 2024-08-04 20:05:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gopher9511/article/details/140910941
版权

继承

派生类的拷贝构造

拷贝构造，也是一种构造函数，也没有被继承下来。

语法:

派生类::派生类(const 派生类& another):基类(another),派生类新成员(another.新成员)
{
    //派生类新成员(another.新成员)
}

构造顺序

在这里插入图片描述

父类中，一部分成员需要拷贝构造来完成，

子类中，也有一部成员需要拷贝构造来完成。

子类中的内嵌子对象也需要拷贝构造来完成

拷贝构造

引例1: 当子类,不自实现拷贝构造时,默认调用父类的拷贝构造

#include <iostream>
using namespace std;


//当子类,不自实现拷贝构造时,默认调用父类的拷贝构造
class A{
    public:
        A(){
            cout << " A ()" << endl;
        }
        A(const A& other){
            cout << " A (const A& other)" << endl;
        }

};

class B: public A{
public:
    B(){
        cout << " B ()" << endl;
    }

    int b;
};

int main() {

    B b;
    B bb(b);
    
    return 0;
}

输出:
 A ()
 B ()
 A (const A& other)

引例2: 子类自实现拷贝构造,不做特殊处理时,只会调用父类的构造器.

#include <iostream>
using namespace std;

//子类自实现拷贝构造,不做特殊处理时,只会调用父类的构造器.
class A{
    public:
        A(){
            cout << " A ()" << endl;
        }
        A(const A& other){
            cout << " A (const A& other)" << endl;
        }

};

class B: public A{
public:
    B(){
        cout << " B ()" << endl;
    }
    B(const B& other){
        cout << " B (const A& other)" << endl;
    }


    int b;
};


int main() {

    B b;
    B bb(b);
    
    return 0;
}

输出:
 A ()
 B ()
 A ()
 B (const A& other)

引例3: 显示的调用父类的拷贝构造器。

#include <iostream>
using namespace std;


//当子类,不自实现拷贝构造时,默认调用父类的拷贝构造
//子类自实现拷贝构造,不做特殊处理时,只会调用父类的构造器.
class A{
    public:
        A(int x){
            a=x;
            cout << " A ()" << endl;
        }
        A(const A& other){
            a=other.a;
            cout << " A (const A& other)" << endl;
        }
        int a;
};

class B: public A{
public:
    B(int x,int b):A(x){
        this->b=b;
        cout << " B ()" << endl;
    }
    
    //显示的调用父类的拷贝构造器。     //子类对象赋值给父类引用,赋值兼容
    B(const B& other):A(other){
        b=other.b;
        cout << " B (const A& other)" << endl;
    }


    int b;
};


int main() {
    B b(200,100);
    B bb(b);
    cout<<b.a<<endl;
    cout<<b.b<<endl;
    return 0;
}

案例:

# include <iostream>
using namespace std;

class Birthday{
private:
    int year_;
    int month_;
    int day_;


public:
    Birthday(int year=0, int month=0, int day=0): year_(year), month_(month), day_(day){}
    void Birthdayprint(){
        cout <<"Birthday:"<< year_ << "/" << month_ << "/" << day_ << endl;
    }

};

class Student{
private:
    Birthday birthday_;
    string name_;
    char sex_;
    float score_;

public:
    Student(string name, char sex, float score , int year, int month, int day): name_(name), sex_(sex), score_(score),birthday_(year, month, day){}
    Student(const Student& other){
        cout<<" Student (const Student& other)"<<endl;
        this->name_ = other.name_;
        this->sex_ = other.sex_;
        this->score_ = other.score_;
    }

    void print(){
        cout << "Name: " << name_ << endl;
        cout << "Sex: " << sex_ << endl;
        cout << "Score: " << score_ << endl;
        birthday_.Birthdayprint();
    }
};


class Graduate: public Student{
private:
    float salary_;

public:
    Graduate(string name, char sex, float score, float salary, int year, int month, int day): Student(name, sex, score, year, month, day), salary_(salary){}

    Graduate(const Graduate& other):Student(other){
        cout<<" Graduate (const Graduate& other)"<<endl;
        this->salary_ = other.salary_;
    }
    void pri(){
        print();
        cout << "Salary: " << salary_ << endl;
    }
};

class Doctor: public Graduate{
private:
    string title_;
public:
    Doctor(string name, char sex, float score, float salary, int year, int month, int day, string title): Graduate(name, sex, score, salary, year, month, day), title_(title){}
    Doctor(const Doctor& other):Graduate(other){
        cout << " Doctor (const Doctor& other)" << endl;
        this->title_ = other.title_;
    }


    void Dpri(){
        pri();
        cout << "Title: " << title_ << endl;
    }
};


int main(){

    Graduate g("Alice", 'F', 95.5, 5000 , 2000, 1, 1);
    g.pri();
    cout <<"==============="<< endl;
    Doctor d("Bob", 'M', 85.0, 4000, 2000, 1, 1, "Doctor");
    d.Dpri();

    cout <<"==============="<< endl;


    Doctor d2(d);
    d2.Dpri();

    return 0;
}

内嵌函数的拷贝构造

引例1 :当内嵌子对象,子类不自实现拷贝构造时,默认调用内嵌子对象的拷贝构造

#include <iostream>
using namespace std;
//todo 内嵌子对象

class C{
public:
    
    C(){
        cout << " C ()" << endl;
    }
    C(const C& other){
        cout << " C (const C& another)" << endl;
    }

};

class A{
public:
    A(int x){
        a=x;
        cout << " A ()" << endl;
    }

    A(const A& other){
        a=other.a;
        cout << " A (const A& other)" << endl;
    }
    int a;
};

class B: public A{
public:
    B(int x,int b):A(x){
        this->b=b;
        cout << " B ()" << endl;
    }
    //当内嵌子对象,子类不自实现拷贝构造时,默认调用内嵌子对象的拷贝构造
    int b;
    C c;
};


int main() {

    B b(200,100);
    B bb(b);


    return 0;
}

输出:
A ()
 C ()
 B ()
 A (const A& other)
 C (const C& another)

引例2: 子类自实现的拷贝构造,不做特殊处理,此时只会调用内嵌对象的构造器,此时失去了内嵌对象的拷贝构造的意义


#include <iostream>
using namespace std;
//todo 内嵌子对象

class C{
public:
    C(){
        cout << " C ()" << endl;
    }
    C(const C& other){
        cout << " C (const C& another)" << endl;
    }

};

class A{
public:
    A(int x){
        a=x;
        cout << " A ()" << endl;
    }

    A(const A& other){
        a=other.a;
        cout << " A (const A& other)" << endl;
    }
    int a;
};

class B: public A{
public:
    B(int x,int b):A(x){
        this->b=b;
        cout << " B ()" << endl;
    }
    //子类自实现的拷贝构造,不做特殊处理,此时只会调用内嵌对象的构造器,此时失去了内嵌对象的拷贝构造的意义
    B(const B& other):A(other){
        b=other.b;
        cout << " B (const A& other)" << endl;
    }


    int b;
    C c;
};


int main() {

    B b(200,100);
    B bb(b);


    return 0;
}



输出:
 A ()
 C ()
 B ()
 A (const A& other)
 C ()
 B (const A& other)

引例3: 显示的调用内嵌对象的拷贝构造器


#include <iostream>
using namespace std;
//todo 内嵌子对象

class C{
public:
    //当内嵌子对象,
    C(){
        cout << " C ()" << endl;
    }
    C(const C& other){
        cout << " C (const C& another)" << endl;
    }

};

class A{
public:
    A(int x){
        a=x;
        cout << " A ()" << endl;
    }

    A(const A& other){
        a=other.a;
        cout << " A (const A& other)" << endl;
    }
    int a;
};

class B: public A{
public:
    B(int x,int b):A(x){
        this->b=b;
        cout << " B ()" << endl;
    }
    //显示调用内嵌子对象的拷贝构造
    B(const B& other):A(other),c(other.c){
        b=other.b;
        cout << " B (const A& other)" << endl;
    }
    int b;
    C c;
};


int main() {

    B b(200,100);
    B bb(b);
    return 0;
}


输出:
 A ()
 C ()
 B ()
 A (const A& other)
 C (const C& another)
 B (const A& other)

案例:

# include <iostream>
using namespace std;

class Birthday{
private:
    int year_;
    int month_;
    int day_;


public:
    Birthday(int year=0, int month=0, int day=0): year_(year), month_(month), day_(day){}
    Birthday(const Birthday& other){
        cout<<" Birthday (const Birthday& other)"<<endl;
        this->year_ = other.year_;
        this->month_ = other.month_;
        this->day_ = other.day_;
    }
    void Birthdayprint(){
        cout <<"Birthday:"<< year_ << "/" << month_ << "/" << day_ << endl;
    }
};

class Student{
private:

    string name_;
    char sex_;
    float score_;
    Birthday birthday_;
public:
    Student(string name, char sex, float score , int year, int month, int day): name_(name), sex_(sex), score_(score),birthday_(year, month, day){}
    Student(const Student& other):birthday_(other.birthday_){
        cout<<" Student (const Student& other)"<<endl;
        this->name_ = other.name_;
        this->sex_ = other.sex_;
        this->score_ = other.score_;
    }

    void print(){
        birthday_.Birthdayprint();
        cout << "Name: " << name_ << endl;
        cout << "Sex: " << sex_ << endl;
        cout << "Score: " << score_ << endl;
    }
};


class Graduate: public Student{
private:
    float salary_;
public:
    Graduate(string name, char sex, float score, float salary, int year, int month, int day):Student(name, sex, score, year,  month,  day), salary_(salary){}

    Graduate(const Graduate& other):Student(other){
        cout<<" Graduate (const Graduate& other)"<<endl;
        this->salary_ = other.salary_;
    }
    void pri(){
        print();
        cout << "Salary: " << salary_ << endl;
    }
};

class Doctor: public Graduate{
private:
    string title_;
public:
    Doctor(string name, char sex, float score, float salary, int year, int month, int day, string title): Graduate(name, sex, score, salary, year, month, day), title_(title){}
    Doctor(const Doctor& other):Graduate(other){
        cout << " Doctor (const Doctor& other)" << endl;
        this->title_ = other.title_;
    }
    void Dpri(){
        pri();
        cout << "Title: " << title_ << endl;
    }
};


int main(){

    Graduate g("Alice", 'F', 95.5, 5000 , 2000, 1, 1);
    g.pri();
    cout <<"==============="<< endl;
    Doctor d("Bob", 'M', 85.0, 4000, 2111, 1, 1, "Doctor");
    d.Dpri();

    cout <<"==============="<< endl;


    Doctor d2(d);
    d2.Dpri();

    return 0;
}


输出Birthday:2000/1/1
Name: Alice
Sex: F
Score: 95.5
Salary: 5000
===============
Birthday:2111/1/1
Name: Bob
Sex: M
Score: 85
Salary: 4000
Title: Doctor
===============
 Birthday (const Birthday& other)
 Student (const Student& other)
 Graduate (const Graduate& other)
 Doctor (const Doctor& other)
Birthday:2111/1/1
Name: Bob
Sex: M
Score: 85
Salary: 4000
Title: Doctor
可能只会写BUG
关注
专栏目录
C++. 派生类的复制操作也必须处理它的基类成员的复制
paradox_1_0的博客
05-07 352
class Copy { public: Copy(){} Copy(int c) : c_(c){} private: int c_; }; class Copytest : public Copy { public: Copytest(){} Copytest(int a, int c) : a_(a), Copy(c) { } Copytest(const Copytes...
C++ 派生类的拷贝构造函数
NuYoaH502329的博客
08-06 492
当存在类的继承关系时，对于一个类，如果程序员没有编写拷贝构造函数，编译系统会在必要时自动生成一个隐含的拷贝构造函数，这个隐含的拷贝构造函数会自动调用基类的拷贝构造函数，然后对派生类新增的成员对象一一执行拷贝。如果要为派生类编写拷贝构造函数，一般需要为基类相应的拷贝构造函数传递参数。由于类型兼容规则的作用，可以用派生类的对象去初始化基类的引用，所以上面B类的拷贝构造函数的参数是D类对象的引用dd。
简要谈谈C++继承中派生类的 构造 拷贝 赋值 析构的调用问题
呋喃吖的博客
04-07 1311
文章目录继承体系派生类的特殊函数调用规则演示验证派生类调用父类的构造和赋值运算符总结： 继承体系派生类的特殊函数调用规则 C++中有如下规则： 基类有默认构造函数，派生类假如不显示调用基类的默认构造函数，那么派生类的构造函数会自动调用基类的默认构造函数；假如基类没有默认构造函数，那么派生类必须显示的去调用基类的其他构造函数； 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。假如派生类不调用基类的拷贝构造就会报错 派生类的operator=必须要调用基类的operator=完成基
C++拷贝继承中的构造函数
weixin_44871977的博客
07-16 807
#include <iostream> using namespace std; class A { public: int x; A(){} A(A &a) { this->x = a.x; cout<<"Copy A";} }; class B:public A { public: int y; B(){} //B(B &b):A(b) //{
C++类继承基础5——构造函数与拷贝控制
2301_80224556的博客
03-30 816
{public: // 默认情况下，基类的默认构造函数初始化对象的基类部分// 要想使用拷贝或移动构造函数，我们必须在构造函数初始值列表中// 显式地调用该构造函数D(const D& d): Base(d) // 拷贝基类成员/*D的成员的初始值*/{/*...*/}D(D&& d): Base (std::move (d)) //移动基类成员/* D的成员的初始值*/{}初始值Base(d)将一个D对象传递给基类构造函数。
C++类的继承——派生类详解
m0_56745306的博客
07-18 3530
第七章 继承(类的复用)——派生类 1.单继承 格式 class <派生类名>: <继承方式> <基类名> { <成员说明表> } 继承方式可以是public，private，protected #include<iostream> using namespace std; class A { int x, y; public: void f() { cout << "这是A中的f。" << endl; } void
C++ 入门10：继承和派生类
LF__plus的博客
07-13 1351
在前面文章的学习中，我们了解了类和对象的基础知识、构造函数、拷贝构造函数、静态成员、常量成员、运算符重载、友元函数和友元类。今天，我们将学习 C++ 中的继承和派生类。继承是面向对象编程中的一个重要概念，它允许我们创建一个新的类，该类继承一个或多个现有类的属性和方法，从而实现代码的重用和扩展。
C++学习笔记（Day12 派生类的构造函数、复制构造函数）
Seasonboboo的博客
10-14 1139
默认情况下 基类的构造函数不被继承 派生类需要定义自己的构造函数 C++11规定（建议不要用） 可用using语句继承基类构造函数； 只能初始化从基类继承的成员。 语法形式：using B::B; 建议 如果派生类有自己新增的成员，且需要通过构造函数初始化，则派生类要自定义构造函数。 若不继承基类的构造函数 派生类新增成员：派生类定义构造函数初始化； 继承来的成员：自动调用基类构造函数进行初始化； 派生类的构造函数需要给基类的构造函数传递参数。 单继承 派生类只有一个直接基类的情况，.
C++派生类的构造函数
一首小夜曲
08-14 1625
派生类的构造函数 默认情况 基类的构造函数不被继承; 派生类需要定义自己的构造函数。 C++11规定 可用using语句继承基类构造函数。 但是只能初始化从基类继承的成员。 派生类新增成员可以通过类内初始值进行初始化。 语法形式： using B::B; 所以如果派生类有自己新增的成员，且需要通过构造函数初始化，则派生类要自定义构造函数。 拓展之using申明： 如果进行
C++ 继承性：派生类
夏牧子的博客
05-17 2261
C++继承性：派生类 继承：继承是面向对象程序设计的一个重要机制，该机制自动地为一个类提供来自另一个类的操作和数据结构，这使程序员只需在新类中定义已有类中没有的成员来建立新类。即，它允许在既有类的基础上来创建新的类，新类可以从一个或多个既有类中继承函数和数据，可以重新定义或加进新的数据和函数，从而新类不但可以共享原有类的属性，并且具有新的特性，这样就形成类的层次。 在C++中，通过...
C++继承与派生类习题.docx
02-27
在C++编程语言中，继承和派生是面向对象编程的重要特性，它们允许创建新的类（派生类）基于已存在的类（基类），从而实现代码重用和类的分级结构。以下是对这些知识点的详细解释： 1. **继承与派生**： - 继承是指...
C++ 继承和派生
Mi-ronin的博客
10-14 1785
继承与派生 一.继承和派生机制 二.层次概念 三.继承语法 3.1 继承格式 3.2 编制派生类时可分四步 为什么构造函数与析构函数不可以被继承？ 3.3 继承关系的访问限定符 3.4 继承基类成员访问方式的变化 3.5 继承中的作用域 同名隐藏与函数重载，函数重写的区别 3.8 派生类的默认成员函数 3.7 继承与静态成员 3.8 继承与友元 3.9 菱形继承与虚拟继承 四.公有继承/私有继承/保护继承的区别 五.公有继承与私有继承和组合怎样选择
c++继承构造函数
热门推荐
digitalkee的博客
12-18 1万+
【1】为什么需要继承构造函数？ 首先，看看如下代码片段： 1 struct A 2 { 3 A(int i) 4 {} 5 }; 6 7 struct B : A 8 { 9 B(int i) : A(i) 10 {} 11 }; 在C++中非常常见：B派生于A，B在构造函数中调用A的构造函数，从而完成构造函数的“传递”。 有时候，基类可能拥有数量众多的不同版本的构造函数（这样的情况并不少见）。 那么，倘若基类中有大量的构造函数
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1294
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
大话C++：第15篇 友元
whccf的博客
10-09 943
友元（Friend）是C++中的一个特殊概念，它允许一个类或函数访问另一个类的私有和保护成员。友元可以是一个函数，也可以是一个类。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 960
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
【C++力扣】917.仅仅反转字母|387.字符串中第一个唯一字符|415.字符串相加
白乐天_ξ( ✿＞◡❛)的博客
10-06 665
本文写的是力扣三道题的解答：917、387、415题，都是与string字符串有关的！
C++文档数据保存与解析
最新发布
一个大佬的博客
10-12 224
【代码】C++文档数据保存与解析。
C++派生类构造函数
12-13
C++中的派生类构造函数需要调用基类的构造函数来初始化从基类继承过来的数据。派生类构造函数的一般格式如下： ```c++ class Derived : public Base { public: Derived(args) : Base(args), member(args) { // 派生类构造函数的其他操作 } private: member_type member; }; ``` 在派生类的生成过程中，派生类继承基类的大部分成员，但不继承基类的构造函数和析构函数（包括拷贝构造函数）。因此，在派生类的构造函数中，需要显式地调用基类的构造函数来初始化从基类继承过来的数据。在调用基类构造函数时，需要使用初始化列表来指定参数。 继承机制下的构造函数的调用顺序是：先调用基类的构造函数，再调用成员变量的构造函数，最后调用派生类自身的构造函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

可能只会写BUG

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

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

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

打赏作者

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

抵扣说明：

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

余额充值