[C++] 继承和动态内存管理

最新推荐文章于 2023-02-06 12:16:48 发布
最新推荐文章于 2023-02-06 12:16:48 发布
阅读量282 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fightfightfight/article/details/84657437
版权

在继承中，需要特别注意对动态内存的处理，当操作基类和派生类对象时，如果管理不当，就会造成如内存的二次释放、派生类内存未释放等问题。申请内存时需要在构造函数(尤其是拷贝构造函数)、赋值运算符中使用new来申请，在释放内存时则需要在析构函数中使用delete释放。

下面就来看看继承中和如何合理地通过拷贝构造、赋值运算符、析构函数来管理动态内存。

1.基类中未使用动态内存分配，派生类中未使用动态内存分配

  • 拷贝构造函数:编译器提供的默认拷贝构造进行成员复制，对于基类的成员，会自动使用基类拷贝构造函数进行复制，由于不存在new分配内存，因此默认拷贝构造函数可以满足成员的复制。

  • 赋值运算符:编译器提供的默认赋值运算符进行成员复制，对于基类的成员将自动使用基类的赋值运算符进行成员复制，由于不存在new分配内存，因此默认赋值运算符可以满足成员的复制。

  • 析构函数: 若派生类中不提供，编译器提供默认析构函数，由于不存在new分配内存，因此可以使用默认析构函数。

示例：

//dma_in_extends.h

namespace DMA_V1{

class Person
{
private:
        int age;
        char name[40];
public:
        Person(const char * ch = "null", int age = 0); 
        virtual void show() const;
};

class Student : public Person
{
private:
        char school[40];
public:
        Student(const char * name = "null", const char * school = "null", int age = 0); 
        virtual void show() const;
};
}

// dma_in_extends.cpp
#include <iostream>
#include <cstring>
#include "dma_in_extends.h"

namespace DMA_V1 {
Person::Person(const char * ch, int age) {
        std::strcpy(name,ch);
        this->age = age;
}

void Person::show() const {
        std::cout << "Name: " << name <<std::endl;
        std::cout << "age: " << age << std::endl;
}

Student::Student(const char * name, const char * school, int age) : Person(name,age) {
        std::strcpy(this->school,school);
}

void Student::show() const {
        Person::show();
        std::cout << "School: " << school << std::endl;
}
}//end DMA_V1

2.基类中未使用动态内存分配，派生类中使用动态内存分配

  • 拷贝构造函数:由于派生类中存在new分配的内存，而默认拷贝构造函数只进行成员复制，因此必须在派生类中重写拷贝构造，基类中无要求(默认拷贝构造可以满足)。

  • 赋值运算符:由于派生类中存在new分配的内存，默认赋值运算符也只进行成员的复制，因此需要重载赋值运算符。基类中无要求(默认赋值运算符可以满足)。

  • 析构函数: 由于派生类中存在new分配内存，因此基类中应声明虚析构函数，以确保正确释放内存，派生类中必须提供析构函数，并在析构函数中使用delete释放内存。

示例：

//dma_in_extends.h

namespace DMA_V2{

class Person
{
private:
        int age;
        char name[40];
public:
        Person(const char * ch = "null", int age = 0); 
        virtual void show() const;
        //由于派生类中存在new分配内存，因此需要声明为虚析构
        virtual ~Person();
};

class Student : public Person
{
private:
        char * school;
public:
        Student(const char * name = "null", const char * school = "null", int age = 0); 
        virtual void show() const;
        //由于char * school的存在，需要定义拷贝构造、赋值运算符和析构函数
        Student(const Student & stu);
        Student & operator=(const Student & stu);
        virtual ~Student();
};
}//enf DMA_V2

//dma_in_extends.cpp

namespace DMA_V2 {
Person::Person(const char * ch, int age) {
        std::strcpy(name,ch);
        this->age = age;
}

void Person::show() const {
        std::cout << "Name: " << name <<std::endl;
        std::cout << "age: " << age << std::endl;
}

Person::~Person() {
        std::cout << "~Person()" << ",delete " << name << std::endl;
}

Student::Student(const char * name, const char * school, int age) : Person(name,age) {
        int len = std::strlen(school);
        this->school = new char[len + 1]; 
        std::strcpy(this->school,school);
}

Student::Student(const Student & stu):Person(stu) {
        int len = std::strlen(stu.school);
        this->school = new char[len + 1]; 
        std::strcpy(this->school,stu.school);
}

Student & Student::operator=(const Student & stu) {
        if (this == & stu)
                return *this;
        delete [] school;
        Person::operator=(stu);//复制基类中的成员
        int len = std::strlen(stu.school);
        this->school = new char[len + 1]; 
        std::strcpy(this->school,stu.school);
        return *this;
}

Student::~Student() {
        std::cout << "~Student()" << " ,delete:" << school << std::endl;
        delete [] school;
}
void Student::show() const {
        Person::show();
        std::cout << "School: " << school << std::endl;
}
}//end DMA_V2

3.基类中使用动态内存分配，派生类中未使用动态内存分配。

  • 拷贝构造函数:由于存在new分配的内存，默认拷贝构造仅仅对成员进行复制，因此需要实现拷贝构造。而派生类中不存在new内存，因此可以使用默认拷贝构造函数。

  • 赋值运算符:由于存在new分配的内存，默认赋值运算符仅仅对成员进行复制，因此需要重载赋值运算符。而派生类中不存在new分配内存，因此可以使用默认赋值运算符，。

  • 析构函数: 由于基类中存在new内存，因此必须提供析构函数，并在析构函数中使用delete释放内存。而派生类中不存在new内存，因此可以使用默认析构函数。

示例:

//dma_in_extends.h

namespace DMA_V3{

class Person
{
private:
        int age;
        char * name;
public:
        Person(const char * ch = "null", int age = 0);
        virtual void show() const;
        //由于需要new 分配内存，因此需要重写拷贝构造，赋值运算符和虚析构
        Person(const Person & p);
        Person & operator=(const Person & p);
        virtual ~Person();
};

class Student : public Person
{
private:
        char school[40];
public:
        Student(const char * name = "null", const char * school = "null", int age = 0);
        virtual void show() const;
};
}//end DMA_V3

//dma_in_extends.cpp

namespace DMA_V3 {
Person::Person(const char * ch, int age) {
        int len = std::strlen(ch);
        name = new char[len + 1];
        std::strcpy(name,ch);
        this->age = age;
}

Person::Person(const Person & p) {
        int len = std::strlen(p.name);
        name = new char[len + 1];
        std::strcpy(name,p.name);
        this->age = p.age;
}

Person & Person::operator=(const Person & p) {
        int len = std::strlen(p.name);
        name = new char[len + 1];
        std::strcpy(name,p.name);
        this->age = p.age;
        return *this;
}
Person::~Person() {
        std::cout << "~Person(), delete " << name << " object" << std::endl;
        delete [] name;
}

void Person::show() const {
        std::cout << "Name: " << name <<std::endl;
        std::cout << "age: " << age << std::endl;
}

Student::Student(const char * name, const char * school, int age) : Person(name,age) {
        std::strcpy(this->school,school);
}

void Student::show() const {
        Person::show();
        std::cout << "School: " << school << std::endl;
}
}//end DMA_V3

4.基类中使用动态内存分配，派生类中使用动态内存分配。

  • 拷贝构造函数:由于存在new分配的内存，默认拷贝构造仅仅对成员进行复制，因此需要在基类和派生类中都要重写拷贝构造。

  • 赋值运算符:由于存在new分配的内存，默认赋值运算符仅仅对成员进行复制，因此需要在基类和派生类中都要重写赋值运算符。

  • 析构函数: 由于存在new分配的内存，因此基类和派生类都必须提供析构函数，析构函数中使用delete释放内存，并在将基类析构声明为虚析构。

示例：

//dma_in_extends.h

namespace DMA_V4 {

class Person
{
private:
        int age;
        char * name;
public:
        Person(const char * ch = "null", int age = 0);
        Person(const Person & p);
        Person & operator=(const Person & p);
        ~Person();
        virtual void show() const;
};

class Student : public Person
{
private:
        char * school;
public:
        Student(const char * name = "null", const char * school = "null", int age = 0);
        Student(const Student & stu);
        Student & operator=(const Student & stu);
        virtual ~Student();
        virtual void show() const;
};
}//end DMA_V4

//dma_in_extends.cpp

namespace DMA_V4 {
Person::Person(const char * ch, int age) {
        int len = std::strlen(ch);
        name = new char[len + 1];
        std::strcpy(name,ch);
        this->age = age;
}

Person::Person(const Person & p) {
        int len = std::strlen(p.name);
        name = new char[len + 1];
        std::strcpy(name,p.name);
        this->age = p.age;
}

Person & Person::operator=(const Person & p) {
        int len = std::strlen(p.name);
        name = new char[len + 1];
        std::strcpy(name,p.name);
        this->age = p.age;
        return *this;
}

Person::~Person() {
        delete [] name;
}

void Person::show() const {
        std::cout << "Name: " << name <<std::endl;
        std::cout << "age: " << age << std::endl;
}

Student::Student(const char * name, const char * school, int age) : Person(name,age) {
        int len = std::strlen(school);
        this->school = new char[len + 1];
        std::strcpy(this->school,school);
}

Student::Student(const Student & stu):Person(stu) {
        int len = std::strlen(stu.school);
        this->school = new char[len + 1];
        std::strcpy(this->school,stu.school);
}

Student & Student::operator=(const Student & stu) {
        int len = std::strlen(stu.school);
        this->school = new char[len + 1];
        std::strcpy(this->school,stu.school);
}

Student & Student::operator=(const Student & stu) {
        if (this == & stu)
                return *this;
        delete [] school;
        Person::operator=(stu);
        int len = std::strlen(stu.school);
        this->school = new char[len + 1];
        std::strcpy(this->school,stu.school);
        return *this;
}

Student::~Student() {
        delete [] school;
}
void Student::show() const {
        Person::show();
        std::cout << "School: " << school << std::endl;
}
}//end DMA_V4

总结

总而言之，若基类和派生类中都存在动态内存分配时，必须重写它们的拷贝构造、析构函数和赋值运算符，且派生类中必须使用相应的基类方法来处理继承自基类元素，但对于这三种函数，它们的处理方式有所不同，通过上述示例我们也看到：

  • 1.对于拷贝构造函数，在派生类中是通过成员初始化列表调用积累的拷贝构造完成的。
  • 2.对于赋值运算符，在派生类中是通过使用作用域解析符显式地调用基类的赋值运算符来完成的。
  • 3.对于析构函数，编译器将自动调用。
FightFightFight
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 班级学生学期成绩管理系统 单继承
11-27
本班级类CClass的对象成员数组需要在构造函数中用new动态分配内存空间，在析构函数中用delete释放。在CClass类中设计包括能够求解最高成绩、最低成绩和平均成绩以及通过学号查找并输出某个学生全部信息（例如Seek()...
【C++进阶之路】内存管理
Shun_Hua的博客
05-22 465
本文重点：delete和new的原理。概要：内存布局，delete和new ，operator new ，operator delete ，对比malloc，new，free ，delete。定位new，内存泄漏……
C++ | 内存管理
CGod的博客
02-06 510
内存管理的问题其实在C语言的时候就已经有所了解让我们看看C++在这一块有什么新的东西吧！// new/delete 和 malloc/free最大区别是 new/delete //对于【自定义类型】除了开空间还会调用构造函数和析构函数 A * p1 =(A *) malloc(sizeof(A));free(p1);delete p2;
【C++】C/C++内存管理（new和delete详解）
分享学习方面的一些笔记
09-12 2274
C++内存管理：new和delete细节
c++继承中的内存布局
热门推荐
cesc
11-27 1万+
 今天在网上看到了一篇写得非常好的文章，是有关c++类继承内存布局的。看了之后获益良多，现在转在我自己的博客里面，作为以后复习之用。 ——谈VC++对象模型（美）简.格雷程化    译 译者前言 一个C++程序员，想要进一步提升技术水平的话，应该多了解一些语言的语意细节。对于使用VC++的程序员来说，还应该了解一些VC++对于C++的诠释。 Inside the C++ Object
c语言字符函数----strcpy（字符串拷贝）
qq_41908643的博客
02-28 1549
c语言字符函数----strcpy 函数名：strcpy 功 能：字符串拷贝 举 例： #include&lt;stdio.h&gt; #include&lt;string.h&gt; int main() { char name[10]; char name2[]=“hello world”; strcpy(name,name2); printf(“name is ----%s\n”,n...
C++复试和面试题汇总
03-22
语言基础 1、简述 C++语言的特点 • C++在 C 语言的基础上引入了面向对象的机制，同时兼容 C 语言； • C++面向对象包括了封装、继承、...C 语言和 C++的内存管理不太一样，C 中使用 malloc 和 free，C++中使用
基于面向对象（C++）的图书管理系统
最新发布
02-19
本文介绍了一个基于C++语言的图书管理系统的设计和实现。该系统采用面向对象的设计方法，通过控制台应用方式进行开发，实现读者可以查询借阅和归还图书记录、查看和修改个人信息等功能，管理员查询、修改和删除读者...
C++课程设计高校水电管理系统+课程报告
10-16
通过写高校水电管理系统，使我们更好的掌握C++语言，同时更好的掌握面向对象的设计思想。提高学生自我分析问题，解决问题的能力。 研究的内容和方法 ： 本程序通过写文件，将信息从客户终端写入到文件中并保存。在...
C++大作业-银行管理系统源代码
02-27
实现一个简单的银行管理系统，完成用户的开户，开卡，存款，取款和转账业务。 2.基本要求 （1）至少包含5个类（包含必要的构造函数和析构函数），使用面向对象程序设计思想实现； （2）要用到继承与派生，要用到...
C++中继承与动态内存分配
yuxikuo_1的专栏
04-17 1081
第一种情况：派生类不使用new jias
C++ 类继承内存布局
wwater的专栏
11-19 119
C++继承分为两种，普通继承和虚拟继承(virtual)。具体的继承又根据父类中的函数是否virtual而不同。 下面就单继承分为几种情况阐述: 1.普通继承+父类无virtual函数 若子类没有新定义virtual函数 此时子类的布局是 : 由低地址-&gt;高地址 为父类的元素(没有vptr),子类的元素(没有vptr). 若子类有新定义virtual函数 此时子类的布局是 : 由低地...
C++ 继承与动态内存分配
xiaogangjava的博客
05-16 487
C++ 继承与动态内存分配 一、问题导入 （1）继承是怎样与动态内存分配（即使用new与delete）进行互动的呢？ （2）假如基类使用动态内存分配，并重新定义赋值和复制构造函数，这将怎样影响派生类的实现呢？取决于派生类的属 性。 根据上述两个问题，我们接下来看看如下两种情况下，继承与动态内存分配的关系： 二、第一种情况：派生类不使用new 2.1 基类使用动态内存分配 假如基类使用了动态内存分配，如下代码所示： // 基类 // 声明中包含了构造函数使用new时需要的特殊方法：析构函数、复制构造函数和重载
C++内存管理
lesky的专栏
12-25 7112
C++内存管理[导语]内存管理是C++最令人切齿痛恨的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对C++的痛恨，但内存管理在C++中无处不在，内存泄漏几乎在每个C++程序中都会发生，因此要想成为C++高手，内存管理一关是必须要过的，除非放弃C++，转到Java或者.NET，他们的内存管理基本是自动的，当然你也放弃了自
继承和动态内存分配——需要为继承类定义 显式析构函数、复制构造函数和赋值运算符...
weixin_34126557的博客
07-12 82
当派生类使用了new时，必须为派生了定义显式析构函数、复制构造函数和赋值运算符。（这里假设hasDMA类继承自baseDMA类）显式析构函数： baseDMA::~baseDMA() // takes care of baseDMA stuff { delete [] label; } hasDMA::~hasDMA() { delete [] style; ...
[C++] C++转换函数的使用
FightFightFight的博客
03-11 3850
1.构造函数转换和explicit关键字        在学习构造函数转换之前，先来复习下什么是自动类型转换：将一个标准类型的变量赋值给另一个标准类型的变量时，如果这两种类型兼容，则C++自动会将这个值转换为接收变量的值。        什么是构造函数转换呢？通俗来讲，构造函数转换就是用户通过构造函数提供的定义类之间的自动类型转换。它的定义如下：接收一个参数的构造函数可以实现这个参数类型和该类之间...
c++虚继承底层原理
09-14
虚继承是C++中的一种继承方式，用于解决多继承时的菱形继承问题。菱形继承问题指的是在多继承关系中，如果派生类有多个基类，而这些基类又有一个共同的基类，那么最终派生类会包含该共同基类的多份拷贝，导致冗余和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值