c++中动态内存操作

内容要点

C++中涉及动态内存的操作有很多，比如malloc/free、new/delete 、operator new(size_t size)/operator delete(void *ptr)，这些操作的概念相近，相当容易混淆，所以我在这里帮大家理清一下。另外C++中动态数组等相关内容这里也会涉及。

主题1：动态内存操作

主题2：动态数组

重要概念

库函数VS运算符： 库函数在一定程度上独立于语言，存在于外部的库中，编译器只负责保证对库函数的调用的正确性并且生成相应调用代码。而运算符是语言相关的，编译器可以控制对运算符的解释。所以，如果是运算符的话就可以执行更加复杂的操作，比如如对象的构造过程和析构过程。

（ 这里我也不是很理解，只是模糊点懂，希望高人指点迷津）

动态内存操作详解

（ 1）使用库函数 malloc /free 

函数库： stdlib.h

函数原型：

void* malloc (size_t size);

void free (void* ptr);

函数功能：简单地申请/释放内存

注意，以上两个都是库函数，它们只完成简单的内存申请/释放操作，需要关心的是以下两点：

a. malloc申请内存失败时返回NULL， 成功则返回指向申请到的内存的首字节的void*指针。

b. 如果ptr等于NULL的话，free再多遍也没关系。但是如果ptr不等于NULL，重复free两次以上会出错。

(2)使用库函数operator new/operator delete

函数库：new

函数原型：

void* operator new (std::size_t size) throw (std::bad_alloc);
void operator delete (void* ptr) throw();

函数功能：申请/释放内存

用法：

char *p = (char*)operator new(10);

operator delete(p);

这两个函数功能呢与malloc/free相同，但是增加了以下特性：

a. 这两个函数可以被类重载，这样就可以根据自己的需要定制。需要注意的是operator new函数返回类型必须是void* 而第一个参数必须是字节数，可以带其他参数。

class Test
{
    private:
        string str;
    public:
        Test(string s):str(s)
        {
            cout<<"constructor being called!"<<endl;
        }
        Test(){}

        ~Test()
        {
            cout<<"destructor being called!"<<endl;
        }

        void print()
        {
            cout<<str<<endl;
        }


        void* operator new(size_t size)
        {
            cout<<"operator new being called!"<<endl;
            return ::operator new(size);
        }

        void operator delete(void * p)
        {
             cout<<"operator delete being called! "<<endl;
             ::operator delete(p);
        }

};

b. 当申请内存失败时，new不是返回NULL，而是抛出异常（可选），然后由new_handler处理（new_handler可以自己写）。

（3）使用运算符new/delete delete[]    (这里new运算符返回的是对象类型的指针而不是void*类型）

注意，new和delete是C++的运算符而不是来自函数库的库函数。

函数功能：申请/释放对象

用法：

MyClass *p= new MyClass([parameters]);

delete p;

注意：

（1）这里的new是运算符，它主要完成以下项功能

         ----自动计算对象类型的字节数

         ----自动调用operator new函数申请内存

         ----自动调用类型的构造函数

         ----返回对象指针

 如果自己重载过operator new,那么新的operator new将被调用。

（2）这里的delete是运算符，它完成以下功能

  ----调用对象的析构函数

        ----调用operator delete释放内存

 如果自己重载过operator delete,那么新的operator delete将被调用。

（ 如果释放的是动态申请的数组，要用到的运算符是与delete类似的 delete[]）

值得一提的是new运算符是类型安全的。

示例代码：

#include<iostream>
#include<string>
#include<cstdlib>
using namespace std;

class Test
{
    private:
        string str;
    public:
        Test(string s):str(s)
        {
            cout<<"constructor being called!"<<endl;
        }
        Test(){}

        ~Test()
        {
            cout<<"destructor being called!"<<endl;
        }

        void print()
        {
            cout<<str<<endl;
        }


        void* operator new(size_t size)
        {
            cout<<"operator new being called!"<<endl;
            return ::operator new(size);
        }

        void operator delete(void * p)
        {
             cout<<"operator delete being called! "<<endl;
             ::operator delete(p);
        }

};



int main()
{
    Test *t = new Test("initial string");

    delete t;
    
     return 0;
}

运行结果：

 

（4）使用Placement new在指定内存上构造对象

函数库：new

函数原型：

<pre style="margin-top: 0px; margin-bottom: 0px; color: rgb(0, 128, 0); background-color: rgb(250, 255, 250);">void* operator new (std::size_t size, void* ptr) throw();

函数功能：在指定内存块上构造对象

示例代码：

   char *pointer = (char*)::operator new(sizeof(ClassName));

   ClassName *temp = new(pointer) ClassName([parameters]);

   temp->~ClassName();

   operator delete(pointer);<strong>
</strong>

示例代码中，我们先用operator new申请了一块内存，然后调用new (pointer) ClassName([parameters]) 在这块内存上构造类型对象。

注意这里不能使直接用delete p释放内存，因为这样的话对象的析构函数不会被调用。正确的做法是先显式调用对象的析构函数，然后调用operator delete释放掉内存。

动态数组详解

静态数组要求编译时必须知道数组维数，然而在很多情况下，数组维数往往是在运行时才能确定的，所以就需要动态数组。

（1）一维动态数组

申请：

int size = 100;
int *arr = new int[size];

释放：

delete[] arr;

（2）二维动态数组

这里分两种情况：

a. 第一维的维数已知

申请：

int d2 = 100;

int (*arr)[10] = new int[d2][10];

释放：

delete[] arr;

这里的arr是指向数组的指针， 请与指针数组区分开来。

b. 第一维的维数未知

如果不知道第一维的维数，那么知不知道第二维的维数也就无关紧要了。这种情况下申请的做法是将二维数组看成数组的数组处理。

申请：

int d1 = 10;
int d2 = 100;

int ** arrayDim[d2] = new int*[d2];

for (int i=0; i<d2; i++)
{
      arrayDim[i] = new int[d1];
}

释放：

for (int i=0; i<d2; ++i)
{
      delete[] arrayDim[i];
}

delete[] arrayDim;
arrayDim = NULL: