从前一篇《C/C++ 类和内存分配》我们已经简单地提过delete和delete操作符的用法,本文将从C++的语义层面来深入地解析delete和delete[]操作符有关内存管理的细节

delete和delete[]的使用规范

• 对于每个由new操作符号创建的基本数据类型的对象,都需要由一个delete去进行内存回收,这是每个C++程序猿在使用堆时的基本操守。
• 对于new []操作符动创建的基本数据类型的数组(元素是基本数据类型),只需执行delete[]操作符一次性回收内存。
• 根据RAII原则，在类的构造函数中由new初始化的指针类型的属性,同时在必须在其解构函数中具有对应的delete操作,这个对于new[]和delete[]也同样使用。

内存泄漏

没有遵循delete和delete[]使用规范的操作就有可能造成内存泄漏，这个问题是使用new操作符分配内存而事后忘记使用delete()函数和或delete[]操作符释放该内存块，此时C++就发生内存泄漏了。

一个形象的比较，我们将堆空间比喻成公共的WC,那么每个程序猿需要用WC的时就是new/new[]操作,用完WC要冲水就是delete/delete[]操作，一旦某个程序猿写的程序没有去冲水，就会弄的堆奇臭无比，如果每个程序猿都不自觉，堆就无法持续使用了。所以我才说“有new就必有delete，有new[]就必有delete[]”，这是每个C++程序猿的基本操守就是这个道理。

内存泄漏避免的基本方法

• 对于基本数据类型的内存分配/回收，有new就必有delete。
• 对于基本数据类型的数组内存分配/回收,有new[]就必有delete[]。
• 与其手动管理内存，不如尝试使用智能指针。
• 对于一个经常被调用的用户自定义类型的对象来说,应该将任何分配内存的操作封装在对象的构造函数中，并且在解构函数中封装任何释放内存的操作。这正是RAII原则所提倡的,只要满足此原则的任何用户自定义类型的对象，都能在其对象变量离开当前作用域时保证释放内存。

基本数据类型的内存回收

对于由new分配的内存，在程序节结束前,用delete操作符执行内存回收

int main(int argc, char const *argv[])
{
    double *p = new double(72.333);
    double *i = new double(113);

    cout << "p:" << *p << endl;
    cout << "i:" << *i << endl;

    delete p,i;
     p=NULL,i=NULL;

  //在内存回收后,尝试再次访问被回收的内存位置，是一种错误的编成方式
    cout << "p:" << *p << endl;
    cout << "i:" << *i << endl;
    return 0;
}

如果删除了动态分配的原始类型值数组，则不会执行任何特殊操作。

基本数据类型的数组的内存回收

对于由new []操作符分配的内存，在程序节结束前,用delete []操作符执行内存回收

int main(int argc, char const *argv[])
{

    int *arr = new int[10];

    for (size_t i = 0; i < 10; i++)
    {
        arr[i] = i;
    }

    cout << "删除之前!!" << endl;
    for (size_t i = 0; i < 10; i++)
    {
        cout << i << " ";
    }
    cout << endl;

    delete[] arr;
    arr=NULL;

    return 0;
}

删除类类型的动态数组

当用户使用 类似这样的表达式,UserType是用户自定义的类(即struct)。

UserType *tm=new UserType[5];

在使用new []操作符初始化的类类型动态数组,期数组元素是用户自定义类型,那么每个UserType元素内部可能如果存在new操作符初始化的指针类型的属性，我假设你定义的类对象已经遵循delete和delete[]的使用规范中的第一点描述。那么当执行运算符delete [] tm处理该类类型的动态数组，将执行下面两个操作：

• 首先，数组中的每个UserType对象调用其内部的解构函数~UserType的delete操作(如果存在)，解构函数执行对象停止存在时所需的各种清理操作。
• 然后“delete[] tm”才释放tm指针变量所向的内存空间,释放后的内存空间返回到公共池。

删除动态数组中的某个元素

对于一个连续存储的顺序存储结构来说，事实上并不存在删除某个元素的操作，因为new []向堆申请的内存区域是连续的，除非动态数组中不再被使用(这种情况,会使用delete[]操作符释放整个数组占用的内存块),“删除元素”实际就是将数组中“被删除”的某个位置后面的每个元素依次向它的前一个元素覆盖原有位置上的值,然后数组最后一个元素重新赋值一个认为无效的值，并且数据结构内部会有一个数据成员专门记录数组的长度，例如length=length-1;而已，已分配的内存块的尺寸依然不变的。如下图所示，

箭头部分代码赋值操作

我们知道这种数组的伪“删除操作”的时间消耗是O(n),我们的标准库中vector的伪“删除操作”正如图中所示的那样。

使用操作符delete []删除动态分配的数组。 它需要一个指向内存块的指针，该指针先前由运算符new []分配。

解构函数

解构函数的任务是确保返回由对象本身或对象内部定义的属性(类类型的指针变量)从堆中分配的某片内存区域给操作系统。 因此，满足以下情况之一,该对象的解构函数会被隐式和显式调用：

以下情况是为隐式调用对象的解构函数

• 当执行流离开了定义该对象(该对象是局部非静态)的函数作用域时，将自动调用该对象的解构函数。 在函数外部块中某处定义的对象的解构函数在函数终止之前被调用。
• 当程序本身终止时，将调用静态或全局对象的解构函数。

以下情况是为显式调用对象的解构函数

• 动态分配的对象的解构函数，可以使用对象的地址作为delete操作数进行调用,也就是说“delete obj”就会调用obj的解构函数。
• 动态分配对象数组的解构函数由delete []使用数组的第一个元素的地址作为其操作数来调用；
• 通过显式调用对象的解构函数来激活由操作符new初始化的对象的解构函数。

解构函数的示例

• Good对象的构造函数内部使用new操作符为d_desc字段从堆中分配内存并且初始化
• 以此同时，Good的解构函数也在内部显式地执行delete d_desc,这样做符合在类内部通过new操作符初始化的类类型的属性(指针变量)，就必须在该类的解构函数定义相应数量的delete语句用于释放对应的类类型属性(指针变量)所持的内存空间。

我们用一个用物品类Good在类内部定义了一个ProductInfo类型的字段,调用的代码如下

#include "./customer.cpp"
#include "./good.cpp"

using namespace std;
int main(int argc, char const *argv[])
{

    string a_from = "巴西";
    string c_from = "泰国";

    string a_name = "香蕉";
    string c_name = "榴莲";

    Good a{a_name, 5.7, 2.0, a_from};
    Good c{c_name, 13.5, 3, c_from};
    a.display();
    c.display();
    return 0;
}

在本示例中,我们在main函数中定义的Good类型的局部变量a和b,因此它们会在存在于main的栈桢中,内存回收的具体细节如下,栈内存的回收是由编译器自动管理的

在函数内部的局部变量只要不是由new或new[]等操作符初始化的，会在函数完成执行后,由编译器自动回收栈内存，我们这里重点说一下类的内存回收细节。

类的内存回收

内存回收示意图

1. 当main函数执行到return语句之时会隐式调用对象a和对象b的解构函数～Good().

2.由于 a和b的～Good内部显式定义了“delete d_desc”这条语句，因此a和b的解构函数~Good()会分别调用ProductInfo类的解构函数~ProductInfo()。

3. 由于ProductInfo对象的内部存在从堆中动态分配的属性d_makefrom,并且ProductInfo对象的~ProductInfo()内部显式定义了“delete d_makefrom”这条语句,在其解构函数执行过程中也会将变量d_makefrom持有的堆内存返还给操作系统(或内存管理器)。
   ss2.png

ProductInfo类接口
按照约定，先声明构造函数,接着是解构函数，然后再声明其他成员函数。

 #ifndef PRODUCT_INFO_HH
 #define PRODUCT_INFO_HH

 #include <iostream>
 #include <string>

 class ProductInfo{
     double d_weight;         //重量
     std::string *d_makefrom; //产地

 public:
     ProductInfo();
     ProductInfo(double, const std::string &);
     ~ProductInfo();
     const std::string &get_makeFrom();
     double get_weight();
 };
 #endif

ProductInfo的类实现

#include "../header/product_info.hh"

ProductInfo::ProductInfo()
{
    d_weight = 0;
    *d_makefrom = nullptr;
}
ProductInfo::ProductInfo(double weight, 
const std::string &where) : d_weight(weight)
{
    d_makefrom = new std::string(where);
}

ProductInfo::~ProductInfo()
{
    std::cout << std::endl;
    std::cout << "释放内存ProductInfo" <<
 *d_makefrom << std::endl;
    delete d_makefrom;
}

double ProductInfo::get_weight()
{
    return d_weight;
}

const std::string &ProductInfo
::get_makeFrom()
{
    return *d_makefrom;
}

Good商品类接口定义

#ifndef GOOD_HH
#define GOOD_HH
#include "./product_info.hh"
#include <string>
class Good
{
    std::string d_name;
    double d_price;
    ProductInfo *d_desc = nullptr;

public:
    Good();
    Good(std::string &, double, double, std::string &);
    ~Good();

    void display();
};
#endif

Good商品类实现

#include "../header/good.hh"
#include "./product_info.cpp"
#include <cstring>
#include <iostream>

Good::Good()
{
    d_desc = new ProductInfo();
};

Good::Good(std::string &name, double price, 
double weight, std::string &from)
{
    d_desc = new ProductInfo(weight, from);
    d_name = name;
    d_price = price;
};

Good::~Good()
{
    std::cout << std::endl;
    std::cout << "释放内存Good:" << d_name << std::endl;
    delete d_desc;
}

void Good::display()
{
    std::cout << "品名:" << d_name << std::endl;
    std::cout << "价格:" << d_price << "RMB" << std::endl;
    std ::cout << "重量:" << d_desc->get_weight() << "斤" << std::endl;
    std::cout << "产地:" << d_desc->get_makeFrom() << std::endl;
    std::cout << std::endl;
}

结语

我们从C++的语义层面解析了如何正确地使用new[]和delete[]操作，但实际上C++的标准库底层已经提供了一个默认的内存分配器来管理我们的堆内存，有些资料也叫“公共池”,new,new[],delete,delete[]是“公共池”提供给程序猿的api，极大地避免了程序猿对堆内存的过多操作。但作为一个要深挖C++的程序猿来说，了解C++的内存管理工具是如何封装内部实验是大有益处的。我有空的时候，会再谈到这方面。