C/C++内存管理详情

C/C++内存管理

内存管理是C++最令人切齿痛恨的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对C++的痛恨，但内存管理在C++中无处不在，内存泄漏几乎在每个C++程序中都会发生，因此要想成为C++高手，内存管理一关是必须要过的，除非放弃C++，转到Java或者.net，他们的内存管理基本是自动的，当然你也放弃了自由和对内存的支配权，还放弃了C++超绝的性能。
　　程序员们经常编写内存管理程序，往往提心吊胆。如果不想触雷，唯一的解决办法就是发现所有潜伏的地雷并且排除它们，躲是躲不了的。

1. C/C++内存分布

在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。　　

• 栈：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
• 堆：就是那些由 new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个 delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
• 自由存储区：就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
• 全局/静态存储区：全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
• 常量存储区：这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改。　
  

明确区分堆与栈

堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。　

首先，我们举一个例子

void f() { int* p=new int[5]; }

这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中。
这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete [ ]p，这是为了告诉编译器：我删除的是一个数组，编译器就会根据相应的Cookie信息去进行释放内存的工作。

2. C语言中动态内存管理方式

void Test ()
{
 int* p1 = (int*) malloc(sizeof(int));
 free(p1);
 
 // 1.malloc/calloc/realloc的区别是什么？
 int* p2 = (int*)calloc(4, sizeof (int));
 int* p3 = (int*)realloc(p2, sizeof(int)*10);
 
 // 这里需要free(p2)吗？
 free(p3 );
}

2.1 malloc/calloc/realloc和free

malloc

malloc分配的内存是位于堆中的,并且没有初始化内存的内容,因此基本上malloc之后,调用函数memset来初始化这部分的内存空间.

void* malloc (size_t size);

size_t是unsigned int。

malloc:分配一块size Byte大小的内存空间，返回一个指向该块内存开始的指针，指针的类型是void
函数malloc不能初始化所分配的内存空间,而函数calloc能.如果由malloc()函数分配的内存空间原来没有被使用过，则其中的每一位可能都是0;反之, 如果这部分内存曾经被分配过,则其中可能遗留有各种各样的数据.也就是说，使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行,但经过一段时间(内存空间还已经被重新分配)可能会出现问题.

realloc

realloc则对malloc申请的内存进行大小的调整.

void* realloc (void* ptr, size_t size);

realloc可以对给定的指针所指的空间进行扩大或者缩小，无论是扩张或是缩小，原有内存的中内容将保持不变.当然，对于缩小，则被缩小的那一部分的内容会丢失.realloc并不保证调整后的内存空间和原来的内存空间保持同一内存地址.相反，realloc返回的指针很可能指向一个新的地址.
realloc是从堆上分配内存的.当扩大一块内存空间时，realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平；如果数据后面的字节不够，问题就出来了，那么就使用堆上第一个有足够大小的自由块，现存的数据然后就被拷贝至新的位置，而老块则放回到堆上.这句话传递的一个重要的信息就是数据可能被移动.

calloc

为一个大小为num的数组分配内存，每个元素的大小是size，把每个元素初始化为0。

 void* calloc(size_t numElements, size_t sizeOfElement); 

函数calloc() 会将所分配的内存空间中的每一位都初始化为零,也就是说,如果你是为字符类型或整数类型的元素分配内存,那么这些元素将保证会被初始化为0;如果你是为指针类型的元素分配内存,那么这些元素通常会被初始化为空指针;如果你为实型数据分配内存,则这些元素会被初始化为浮点型的零.

3. C++内存管理方式

3.1 new/delete操作内置类型

int *i = new int;             //没有初始值
    int *j = new int(100);         //初始值为100
    int *iArr = new int[3];        //分配具有3个元素的数组
    delete i;                   //释放单个变量所占用的内存
    delete j;
    delete []iArr;               //释放数组所占用的内存

3.2 new和delete操作自定义类型

class Test
{
public:
 Test()
  : _data(0)
 {
  cout << "Test():" << this << endl;
 }
 ~Test()
 {
  cout << "~Test():" << this << endl;
 }

private:
 int _data;
};
void Test2()
{
 // 申请单个Test类型的空间
 Test* p1 = (Test*)malloc(sizeof(Test));
 free(p1);

 // 申请10个Test类型的空间
 Test* p2 = (Test*)malloc(sizoef(Test) * 10);
 free(p2);
}
void Test2()
{
 // 申请单个Test类型的对象
 Test* p1 = new Test;
 delete p1;

 // 申请10个Test类型的对象
 Test* p2 = new Test[10];
 delete[] p2;
}

从上例可看出，new调用了类Test的构造函数，而malloc只是分配了空间，并没有调用构造函数，因此会出现调用Test2函数时，输出的结果具有随机性。如果用free释放“new创建的动态对象”，那么该对象因无法执行析构函数而可能导致程序出错。如果用delete释放“malloc申请的动态内存”，理论上讲程序不会出错，但是该程序的可读性很差。所以new/delete必须配对使用，malloc/free也一样。
上例中，Test为类的析构函数，对象离开作用域或被delete的时候会调用。指针p指向了一个堆上创建的Test对象，若用free来释放内存，则不会调用析构函数

4. operator new与operator delete函数

new和delete操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局
函数来释放空间

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
// try to allocate size bytes
void *p;
while ((p = malloc(size)) == 0)
if (_callnewh(size) == 0)
{
// report no memory
// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
static const std::bad_alloc nomem;
_RaiSE(nomem);
}
return (p);
}

operator new 是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则返回NULL，如果用户提供该措施就继续申请，否则就抛异常。operator delete 是通过free来释放空间的

5. new和delete的实现原理

5.1、new

new操作针对数据类型的处理，分为两种情况：

（1） 简单数据类型（包括基本数据类型和不需要构造函数的类型）

• 简单类型直接调用operator new分配内存；
• 可以通过new_handler来处理new失败的情况；
• new分配失败的时候不像malloc那样返回NULL，它直接抛出异常。要判断是否分配成功应该用异常捕获的机制；

（2）复杂数据类型（需要由构造函数初始化对象）　

new 复杂数据类型的时候先调用operator new，然后在分配的内存上调用构造函数。

5.2、delete

delete也分为两种情况：

• 简单数据类型（包括基本数据类型和不需要析构函数的类型）delete简单数据类型默认只是调用free函数。
• 复杂数据类型（需要由析构函数销毁对象）delete复杂数据类型先调用析构函数再调用operator delete。

5.3、new 数组

new[]也分为两种情况：

•  简单数据类型（包括基本数据类型和不需要析构函数的类型）针对简单类型，new[]计算好大小后调用operator new。
• 复杂数据类型（需要由析构函数销毁对象）针对复杂类型，new[]会额外存储数组大小。

5.4、delete 数组

delete[]也分为两种情况：

• 简单数据类型（包括基本数据类型和不需要析构函数的类型）针对简单类型，delete和delete[]等同。
• 复杂数据类型（需要由析构函数销毁对象）针对复杂类型，new[]出来的内存只能由delete[]释放。
  

到此这篇关于C/C++内存管理详情的文章就介绍到这了,更多相关C/C++内存管理内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！