C/C++内存分布
首先来看一段代码？
#include <iostream>
#include <cstdlib>
int var1 = 1;
static int var2 = 1;
void MemoryTest(){
static int var3 = 1;
int var4 = 1;
int arr1[10] = {
1, 2, 3, 4
};
char arr2[] = "hello, world!";
char* arr3 = "hello, world!";
int* ptr1 = (int*)malloc(sizeof(int) * 4);
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
free(ptr1);
free(ptr3);
}
int main(){
MemoryTest();
system("pause");
return 0;
}
来看下面几个问题：
- var1、var2、var3、var4、arr1、arr2、arr3、ptr1、ptr2、ptr3、*arr2、*arr3、*ptr1分别存在哪？
var1存在数据段，var2存在数据段，var3存在数据段，var4存在栈上；arr1存在栈上，arr2存在栈上，arr3存在栈上，ptr1存在栈上，ptr2存在栈上，ptr3存在栈上；*arr2存在栈上，*arr3存在代码段，*ptr1存在堆上。 - 下面表达式的值分别为多少？
sizeof(arr1)：40；sizeof(arr2)：14；strlen(arr2)：13；sizeof(arr3)：4/8；strlen(arr3)：13；sizeof(ptr1)：4/8。
说明：
- 栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。
- 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，用于进程间通信。
- 堆用于程序运行时动态内存分配，堆是向上增长的。
- 数据段：存储全局数据和静态数据。
- 代码段：可执行的代码/只读常量。
C语言动态内存管理
代码演示
#include <stdio.h>
#include <stdlib.h>
#define N 10
int main(){
int* ptr1 = (int*)malloc(sizeof(int) * N);
int* ptr2 = (int*)calloc(N, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int) * N * 2);
free(ptr1);
free(ptr2);
free(ptr3);
system("pause");
return 0;
}
malloc、calloc、realloc的区别
- malloc就是动态申请一块空间。
- calloc动态申请一块空间，并初始化为0。
- realloc是对动态申请的空间进行扩容。这里注意，如果原空间后有足够的空间来扩容，则直接扩容，否则，系统会重新找一块连续的空间，将数据拷贝过去，并释放原空间。如果realloc的第一个参数为NULL，则等同于malloc。
C++动态内存管理
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力而且使用起来比较麻烦，因此C++提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
内置类型
#include <iostream>
using namespace std;
void MemoryAllocate(){
int* ptr1 = new int;
int* ptr2 = new int(1);
int* ptr3 = new int[5];
delete ptr1;
delete ptr2;
delete[] ptr3;
}
int main(){
MemoryAllocate();
system("pause");
return 0;
}
注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]。
自定义类型
#include <iostream>
class Test{
public:
Test(){
std::cout << "Test()" << std::endl;
}
~Test(){
std::cout << "~Test()" << std::endl;
}
};
int main(){
std::cout << "single: " << std::endl;
Test* ptr1 = new Test;
delete ptr1;
std::cout << "multi: " << std::endl;
Test* ptr2 = new Test[3];
delete[] ptr2;
return 0;
}
[sss@aliyun memory_allocate]$ g++ mem_alloc_class.cc -o mem_alloc_class
[sss@aliyun memory_allocate]$ ./mem_alloc_class
single:
Test()
~Test()
multi:
Test()
Test()
Test()
~Test()
~Test()
~Test()
注意：new和delete操作符针对自定义类型时，new会调用构造函数，delete会调用析构函数。而malloc和free不会。
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)
{
void *p;
while ((p = malloc(size)) == 0)
if (_callnewh(size) == 0)
{
static const std::bad_alloc nomem;
_RAISE(nomem);
}
return (p);
}
void operator delete(void *pUserData)
{
_CrtMemBlockHeader * pHead;
RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
if (pUserData == NULL)
return;
_mlock(_HEAP_LOCK); /* block other threads */
__TRY
/* get a pointer to memory block header */
pHead = pHdr(pUserData);
/* verify block type */
_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
_free_dbg(pUserData, pHead->nBlockUse);
__FINALLY
_munlock(_HEAP_LOCK); /* release other threads */
__END_TRY_FINALLY
return;
}
从上述两个全局函数的源码可以看出，operator new实际也是通过malloc来申请空间的。如果malloc申请空间成功就直接返回，否则抛出异常。operator delete最终是通过free来释放空间的。
new和delete的实现原理
内置类型
如果申请的是内置类型空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
自定义类型
new的原理：
- 调用operator new函数申请空间。
- 在申请的空间上执行构造函数，完成对象的构造。
delete的原理：
- 在空间上执行析构函数，完成对象中资源的清理工作。
- 调用operator delete函数释放对象的空间。
new T[N]的原理：
- 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请。
- 在申请的空间上执行N次构造函数。
delete[]的原理：
- 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理。
- 调用operator delete[]函数释放空间，实际在operatro delete[]中调用operator delete来释放空间。
定位new表达式
首先来看一段代码：
#include <iostream>
class Test{
public:
Test(){
std::cout << "Test()" << std::endl;
}
~Test(){
std::cout << "~Test()" << std::endl;
}
};
int main(){
Test t;
t.Test();
t.~Test();
return 0;
}
[sss@aliyun memory_allocate]$ g++ constructor.cc -o constructor
constructor.cc: In function ‘int main()’:
constructor.cc:17:4: error: invalid use of ‘Test::Test’
t.Test();
^
从上面可以看出，构造函数是自动调用的，没有办法显式调用，析构函数可以显式调用。所以就有了定位new表达式。
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
格式：
new(place_address) type或者new(place_address) type(initializer-list)。place_address必须是一个指针，initializer-list是类型的初始化列表。
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的表达式进行显式调用构造函数进行初始化。
#include <iostream>
#include <stdlib.h>
class Test{
public:
Test(int data)
: _data(data)
{
std::cout << "Test()" << std::endl;
}
~Test(){
std::cout << "~Test()" << std::endl;
}
private:
int _data;
};
int main(){
// pt指向的是一个与Test对象相同大小的一段空间，但还不算一个对象，没有调用构造函数。
Test* pt = (Test*)malloc(sizeof(Test));
new(pt) Test(-1);
return 0;
}
new/delete和malloc/free的区别
共同点：
- 都是从堆上申请空间，并且需要用户手动释放。
不同点：
- malloc和free是函数，new和delete是操作符。
- malloc申请的空间不会初始化，new可以初始化。
- malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可。
- malloc的返回值为void*，在使用时必须强转，new不需要，因为new后跟的是空间类型。
- malloc申请空间失败时，返回NULL，因此使用时需要判空，new不需要，但是new需要捕获异常。
- 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理。
- new/delete比malloc/free的效率稍微低点，因为new/delete的底层封装了malloc/free。
两个有趣的问题
设计一个类，只能在堆上创建对象
class HeapOnly{
public:
static HeapOnly* GetObj(){
return new HeapOnly;
}
private:
HeapOnly(){}
HeapOnly(const HeapOnly&);
};
设计一个类，只能在栈上创建对象
class StackOnly{
public:
static StackOnly* GetObj(){
return StackOnly();
}
private:
HeapOnly(){}
};
内存泄漏
什么是内存泄漏
内存泄漏是指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是说内存在物理上的流失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
// 内存申请了忘记释放。
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
int* p3 = new int[10];
// 这里func函数抛异常导致delete[] p3未执行，p3没释放。
func();
delete[] p3;
内存泄漏分类：
- 堆内存泄漏（Heap Leak）：堆内存指的是程序执行中依据须要分配通过malloc/calloc/realloc/new等从对中分配的一块内存，用完后必须通过调用相应的free或者delete删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
- 系统资源泄露：指程序使用系统分配的资源，比如套接字描述符、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
如何检测内存泄漏
使用内存泄漏检查工具来检查内存泄漏。
比如Linux下的valgrind、Windows下的VLD等待。这里就不一一介绍了。
如何避免内存泄漏
- 养成良好的设计规范和良好的编码规范，申请的内存空间记得去匹配释放。
- 采用RALL思想或者智能指针来管理资源。
- 内存泄漏检测工具。
如何在堆上申请4G空间
32位进程，我们使用malloc最多可以申请2G的空间，但是如果是64位的进程，就可以申请很大，因为64位进程的虚拟地址空间很大很大。
3820
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
