C/C++中的动态内存管理

动态内存管理

  • 内存格局通常分成四个区
    • 全局数据区(data area)
      • 全局变量
      • 静态数据
      • 常量存放
    • 代码区(code area)
      • 所有类成员函数代码
      • 所有非成员函数代码
    • 栈区(stack area)
      • 为运行函数而分配的局部变量
      • 函数参数
      • 返回数据
      • 返回地址等
    • 堆区(自由存储区)(heap area)
  • 为什么要使用new和delete?
    • malloc函数在分配空间的时候不能调用构造函数。
    • 而类对象的建立是分配空间、构造结构以及初始化的三位一体,它们统一由构造函数来完成。
    • 从程序设计的需要来看,在分配内存申请的时候,总是知道分配的空间派什么用,而且分配空间大小总是某个数据类型的整数倍。
    • 因而,C++用new代替C的malloc()是必然的。

C/C++内存管理对比

C语言

  • 动态内存分配函数
    • malloc
    • alloc
    • realloc
    • free
  • realloc,malloc,calloc的区别
    三个函数的申明分别是:
void* realloc(void* ptr, unsigned newsize);   
void* malloc(unsigned size);   
void* calloc(size_t numElements, size_t sizeOfElement);   

都在stdlib.h函数库内。
它们的返回值都是请求系统分配的地址,如果请求失败就返回NULL 。

  • malloc用于申请一段新的地址,参数size为需要内存空间的长度,如:
char* p;   
p=(char*)malloc(20);  

calloc与malloc相似,参数sizeOfElement为申请地址的单位元素长度,numElements为元素个数,如:

char* p;   
p=(char*)calloc(20,sizeof(char));   

realloc是给一个已经分配了地址的指针重新分配空间,参数ptr为原有的空间地址,newsize是重新申请的地址长度 。

char* p;   
p=(char*)alloc(sizeof(char)*20);   
p=(char*)realloc(p,sizeof(char)*40);  

注意,这里的空间长度都是以字节为单位。

  • 区别:
    • 函数malloc不能初始化所分配的内存空间,而函数calloc能。如果由malloc()函数分配的内存空间原来没有被使用过,则其中的每一位可能都是0;反之, 如果这部分内存曾经被分配过,则其中可能遗留有各种各样的数据。也就是说,使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行。但经过一段时间(内存空间还已经被重新分配)可能会出现问题。
    • 函数calloc() 会将所分配的内存空间中的每一位都初始化为零。也就是说,如果你是为字符类型或整数类型的元素分配内存,那么这些元素将保证会被初始化为0;如果你是为指针类型的元素分配内存,那么这些元素通常会被初始化为空指针;如果你为实型数据分配内存,则这些元素会被初始化为浮点型的零。
    • 函数malloc向系统申请分配指定size个字节的内存空间。返回类型是 void*类型。void*表示未确定类型的指针。C、C++规定,void* 类型可以强制转换为任何其它类型的指针。
    • realloc可以对给定的指针所指的空间进行扩大或者缩小,无论是扩张或是缩小,原有内存的中内容将保持不变。当然,对于缩小,则被缩小的那一部分的内容会丢失。realloc并不保证调整后的内存空间和原来的内存空间保持同一内存地址。相反,realloc返回的指针很可能指向一个新的地址。
    • realloc是从堆上分配内存的.当扩大一块内存空间时,realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节,如果能够满足,自然天下太平;如果数据后面的字节不够,问题就出来了,那么就使用堆上第一个有足够大小的自由块,现存的数据然后就被拷贝至新的位置,而老块则放回到堆上。这句话传递的一个重要的信息就是数据可能被移动。
    • calloc在动态分配完内存后,自动初始化该内存空间为零,而malloc不初始化,里边数据是随机的垃圾数据。并且malloc申请的内存可以是不连续的,而calloc申请的内存空间必须是连续的。
    • 当程序运行过程中malloc了,但是没有free的话,会造成内存泄漏.一部分的内存没有被使用,但是由于没有free,因此系统认为这部分内存还在使用,造成不断的向系统申请内存,使得系统可用内存不断减少。但是内存泄漏仅仅指程序在运行时,程序退出时,OS将回收所有的资源。因此,适当的重启一下程序,有时候还是有点作用。

来源: http://blog.csdn.net/shuaishuai80/article/details/6140979

C++

  • new / delete —— 动态内存管理对象
  • new[] / delete[] —— 动态内存管理对象数组
  • new是动态分配内存的运算符,自动计算需要分配的空间,在C++中,它属于重载运算符,可以对多种数据类型形式进行分配内存空间,比如int型、char型、结构体型和类等的动态申请的内存分配,分配类的内存空间时,同时调用类的构造函数,对内存空间进行初始化,即完成类的初始化工作。
  • delete是撤销动态申请的内存运算符。delete与new通常配对使用,与new的功能相反,可以对多种数据类型形式的内存进行撤销,包括类,撤销类的内存空间时,它要调用其析构函数,完成相应的清理工作,收回相应的内存资源。

  • 用法:

void Test ()
{
    int* p4 = new int; // 动态分配 4 个字节( 1 个 int)的空间单个数据
    int* p5 = new int(3); // 动态分配 4 个字节( 1 个 int)的空间并初始化为 3
    int* p6 = new int[3]; // 动态分配 12 个字节( 3 个 int)的空间
    delete p4 ;
    delete p5 ;
    delete[] p6 ;
}

new/delete与malloc/free之间的联系和区别

  • malloc/free和new/delete的联系

    • 存储方式相同。malloc和new动态申请的内存都位于堆中。申请的内存都不能自动被操作系统收回,都需要配套的free和delete来释放。
    • 除了带有构造函数和析构函数的类等数据类型以外,对于一般数据类型,如int、char等等,两组动态申请的方式可以通用,作用效果一样,只是形式不一样。
    • 内存泄漏对于malloc或者new都可以检查出来的,区别在于new可以指明是那个文件的那一行,而malloc没有这些信息。
    • 两组都需要配对使用,malloc配free,new配delete,注意,这不仅仅是习惯问题,如果不配对使用,容易造成内存泄露。同时,在C++中,两组之间不能混着用,虽说有时能编译过,但容易存在较大的隐患。
  • malloc/free和new/delete的区别

    • malloc和free返回void类型指针,new和delete直接带具体类型的指针。
    • malloc和free属于C语言中的函数,需要库的支持,而new/delete是C++中的运算符,况且可以重载,所以new/delete的执行效率高些。C++中为了兼用C语法,所以保留malloc和free的使用,但建议尽量使用new和delete。
    • 在C++中, new是类型安全的,而malloc不是。例如:

      int* p = new char[10];                    // 编译时指出错误  
      delete [ ]p;                                     //对数组需要加中括号“[ ]”  
      int* p = malloc(sizeof(char )*10);    // 编译时无法指出错误  
      free (p);                                       //只需要所释放内存的头指针  
    • 使用new动态申请类对象的内存空间时,类对象的构建要调用构造函数,相当于对内存空间进行了初始化。而malloc动态申请的类对象的内存空间时,不会初始化,也就是说申请的内存空间无法使用,因为类的初始化是由构造函数完成的。delete和free的意义分别于new和malloc相反。

    • 不能用malloc和free来完成类对象的动态创建和删除。

来源:http://blog.csdn.net/kingcat666/article/details/44781983

剖析new/delete和new[]/delete[]

http://blog.csdn.net/hazir/article/details/21413833
这篇博客和博客底下的留言把这个问题剖析的很清楚了,可以多看几遍~

利用宏实现NEW_ARRAY/DELETE_ARRAY,以模拟new[]/delete[]申请和释放数组的功能

#define NEW_ARRAY(P, TYPE, N)                       \
do{                                                 \
    int* P_NEW = (int*)malloc(sizeof(TYPE)*N + 4);  \
    ((int*)P_NEW)[0] = N;                           \
    P = (TYPE*)(P_NEW + 1);                         \
    int I_NEW = 0;                                  \
    for (; I_NEW < N; I_NEW++)                      \
        new(P + I_NEW)TYPE;                         \
} while (false);

#define DELETE_ARRAY(P, TYPE)                       \
do{                                                 \
    int n = *((int*)P - 1);                         \
    while (n--)                                     \
        (P[n]).~TYPE();                             \
    free((int*)P - 1);                              \
} while (false);

1、申请时在数组对象的上面还多分配了 4 个字节用来保存数组的大小,但是最终返回的是对象数组的指针,而不是所有分配空间的起始地址。
2、do{}while(false) 是为了生成一个局部域,定义和使用临时变量,避免变量重定义。

阅读更多
个人分类: C++
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

不良信息举报

C/C++中的动态内存管理

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭