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

最新推荐文章于 2023-05-22 22:10:29 发布
最新推荐文章于 2023-05-22 22:10:29 发布
阅读量322 收藏
点赞数
分类专栏： 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
关注
专栏目录
引发C++程序内存泄漏的原因分析与排查方法总结
dvlinker的技术专栏
08-21 3万+
本文根据多年的项目实践以及遇到的多个内存泄漏的问题案例及场景，详细介绍引发内存泄漏的原因以及排查方法。
使用历史版本比对法排查C++程序中的内存泄漏问题
最新发布
dvlinker的技术专栏
08-07 1万+
本文详细讲述如何使用历史版本比对法去排查C++程序中的内存泄漏问题，并对内存泄漏的相关细节点进行了展开。
C++ 类继承内存布局
wwater的专栏
11-19 147
C++继承分为两种，普通继承和虚拟继承(virtual)。具体的继承又根据父类中的函数是否virtual而不同。 下面就单继承分为几种情况阐述: 1.普通继承+父类无virtual函数 若子类没有新定义virtual函数 此时子类的布局是 : 由低地址-&gt;高地址 为父类的元素(没有vptr),子类的元素(没有vptr). 若子类有新定义virtual函数 此时子类的布局是 : 由低地...
C++中继承与动态内存分配
yuxikuo_1的专栏
04-17 1097
第一种情况：派生类不使用new jias
c++继承中的内存布局
Yates Law的博客
09-22 544
c++继承中的内存布局（转） 今天在网上看到了一篇写得非常好的文章，是有关c++类继承内存布局的。看了之后获益良多，现在转在我自己的博客里面，作为以后复习之用。 ——谈VC++对象模型 （美）简.格雷 程化    译 译者前言 一个C++程序员，想要进一步提升技术水平的话，应该多了解一些语言的语意细节。对于使用VC++的程序员来说，还应该了解一些VC++对于C++的
C++ | 内存管理
CGod的博客
02-06 627
内存管理的问题其实在C语言的时候就已经有所了解让我们看看C++在这一块有什么新的东西吧！// new/delete 和 malloc/free最大区别是 new/delete //对于【自定义类型】除了开空间还会调用构造函数和析构函数 A * p1 =(A *) malloc(sizeof(A));free(p1);delete p2;
【C++进阶之路】内存管理
Shun_Hua的博客
05-22 694
本文重点：delete和new的原理。概要：内存布局，delete和new ，operator new ，operator delete ，对比malloc，new，free ，delete。定位new，内存泄漏……
C++ 中继承与动态内存分配的详解
08-29
在C++编程语言中，继承和动态内存分配是两个核心概念，它们分别涉及到面向对象设计和内存管理。继承允许一个类（派生类）从另一个类（基类）获取特性，从而实现代码重用和类层次结构的构建。动态内存分配则是在运行...
类继承（动态内存分配）
11-09
类继承和动态内存分配是C++编程中两个重要的概念，它们在实际开发中结合使用时，可以实现更灵活和高效的设计。在这个主题中，我们将深入探讨如何在类继承的环境中运用动态内存分配，并通过示例代码来理解这三种情况...
C++对象内存模型.pdf
04-18
本文讨论了 C++ 对象内存模型的基本概念和结构，并通过实验和分析来探索对象内存结构、简单类型相关数据、包含虚函数类的对象内存结构、继承下的多态性等问题。理解 C++ 对象内存模型对于 C++ 编程语言的学习和应用...
【C++】C/C++内存管理（new和delete详解）
分享学习方面的一些笔记
09-12 2475
C++内存管理：new和delete细节
继承和动态内存分配——需要为继承类定义 显式析构函数、复制构造函数和赋值运算符...
weixin_34126557的博客
07-12 100
当派生类使用了new时，必须为派生了定义显式析构函数、复制构造函数和赋值运算符。（这里假设hasDMA类继承自baseDMA类）显式析构函数： baseDMA::~baseDMA() // takes care of baseDMA stuff { delete [] label; } hasDMA::~hasDMA() { delete [] style; ...
C++ 继承与动态内存分配
xiaogangjava的博客
05-16 544
C++ 继承与动态内存分配 一、问题导入 （1）继承是怎样与动态内存分配（即使用new与delete）进行互动的呢？ （2）假如基类使用动态内存分配，并重新定义赋值和复制构造函数，这将怎样影响派生类的实现呢？取决于派生类的属 性。 根据上述两个问题，我们接下来看看如下两种情况下，继承与动态内存分配的关系： 二、第一种情况：派生类不使用new 2.1 基类使用动态内存分配 假如基类使用了动态内存分配，如下代码所示： // 基类 // 声明中包含了构造函数使用new时需要的特殊方法：析构函数、复制构造函数和重载
C++内存管理
人不一定要生得漂亮，但一定要活得漂亮！
04-16 2878
C++内存管理 [导语]内存管理是C++最令人切齿痛恨的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对C++的痛恨，但内存管理在C++中无处不在，内存泄漏几乎在每个C++程序中都会发生，因此要想成为C++高手，内存管理一关是必须要过的，除非放弃C++，转到Java或者.NET，他们的内存管理基本是自动的，当然你也放
c语言字符函数----strcpy（字符串拷贝）
qq_41908643的博客
02-28 1602
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++] C++转换函数的使用
FightFightFight的博客
03-11 3987
1.构造函数转换和explicit关键字        在学习构造函数转换之前，先来复习下什么是自动类型转换：将一个标准类型的变量赋值给另一个标准类型的变量时，如果这两种类型兼容，则C++自动会将这个值转换为接收变量的值。        什么是构造函数转换呢？通俗来讲，构造函数转换就是用户通过构造函数提供的定义类之间的自动类型转换。它的定义如下：接收一个参数的构造函数可以实现这个参数类型和该类之间...
C++面试精华：动态内存管理与继承详解
1. 动态内存管理：C++中的`new`、`delete`、`malloc`和`free`函数的关系 - `new`和`delete`是C++特有的运算符，分别用于动态分配内存（对象）和释放内存（对象）。它们与C的`malloc`和`free`不同，因为`new`不仅...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值