learn C++ NO.7——C/C++内存管理
引言
现在是5月30日的正午，图书馆里空空的，也许是大家都在午休，也许是现在37摄氏度的气温。穿着球衣的我已经汗流浃背，今天热火战胜了凯尔特人，闯入决赛。以下克上的勇气也激励着我，在省内垫底的大学中，我不觉得气馁，我要更加努力学习，让自己能够越来越好，以后肯定也会”晋级决赛”。
1.C/C++程序的内存分布
- 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
- 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口
创建共享共享内存，做进程间通信。 - 堆用于程序运行时动态内存分配，堆是可以上增长的。
- 数据段–存储全局数据和静态数据。
- 代码段–可执行的代码/只读常量
2.变量在内存中存储的位置
int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[10] = { 1, 2, 3, 4 };
char char2[] = "abcd";
const char* pChar3 = "abcd";
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);
}
下面我按照从左往右从上到下的顺序依次分析上面的题目。globalVar和staticGlobalVar都是定义在全局域中，所以是存储在静态区中的。staticVar虽然是在局部域内定义的，但是它是static修饰的变量所以依旧是存储在静态区中的。localVar和num1都是在局部域内定义的局部变量，都是存储在栈区空间的。上面第一部分比较简单，下面我以画图加分析的来看下面部分。
为什么char2和*char2都在局部域呢？
pChar3是一个定义在栈区的const char类型指针，它保存的是常量字符串"abcd"的首元素地址。*pChar3是对常量字符串的首元素地址进行解引用操作，访问的是常量区的空间。ptr1是一个在栈区上创建的指针变量，存放的是动态开辟空间首字节地址。解引用访问ptr1访问的是堆区空间。
数组名单独放在sizeof内部表示整个数组，所以是4*10字节。"abcd"其实是隐含了’\0’字符，所以是4+1=5字节。无论什么指针都是4 or 8字节，指针的大小取决于平台，64位平台8字节，32位平台4字节。
3.C语言的动态内存管理
常见的C语言动态内存管理如下：malloc/calloc/realloc/free。具体细节可以移步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 );
}
1.malloc就是单纯地开辟堆区空间。calloc是可以指定初始化内容开辟堆区空间。realloc就是动态调整堆区申请的空间。当调整后的空间无法在原空间后扩容，则会将原空间的内容拷贝到新的空间上再申请到连续空间。
4.C++的动态内存管理
因为C++是兼容C语言的，所以C语言的动态内存管理依旧是可以在C++中使用的。由于C语言的动态管理方式存在缺陷，所以C++也提供了两个操作符来进行动态内存管理。分别是new 和 delete。
4.1.new和delete管理内置类型
int main()
{
//c
int* p1 = (int*)malloc(sizeof(int));
free(p1);
//cpp
//new后面跟的是类型
int* p2 = new int;
delete p2;
//malloc单纯开辟空间
//new支持初始化
int* p3 = new int(10);
delete p3;
int* p4 = (int*)malloc(sizeof(int) * 10);
free(p4);
int* p5 = new int[10];
delete[] p5;//一定要带[]
//开辟连续空间也是支持初始化的
int* p6 = new int[10]{1,2,3,4};
delete[] p6;
}
需要注意的是使用malloc申请的内存就用free来释放，使用new申请的内存，就用delete来清理。不可以free来释放new的空间，或者用delete来释放malloc的空间。虽然在内置类型中，可能不会出问题，但是，这样使用是不规范也不正确的。这就好比吃面要用筷子，吃炸鸡要用手套，吃炒饭用勺子。你用free去释放new的内存，就好比用勺子去吃炸鸡，这样是不合适的。在某些场景下，你用free去释放new的内存就会好比用手套去吃火锅，那肯定是不行的。
4.1.new和delete操作自定义类型
struct ListNode
{
//c++写法
ListNode(int x)
:_next(nullptr)
, _val(x)
{}
int _val;
struct ListNode* _next;
};
//c语言写法
struct ListNode* BuyNode(int x)
{
struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
newnode->_next = NULL;
newnode->_val = x;
return newnode;
}
int main()
{
struct ListNode* n1 = BuyNode(1);
struct ListNode* n2 = BuyNode(2);
struct ListNode* n3 = BuyNode(3);
free(n1);
free(n2);
free(n3);
//struct升级成了类
ListNode* nn1 = new ListNode(1);
ListNode* nn2 = new ListNode(2);
ListNode* nn3 = new ListNode(3);
delete nn1;
delete nn2;
delete nn3;
return 0;
}
new可以去调用自定义类型的构造函数来初始化对象，这样写比c语言的写法香多了。
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
A(const A& aa)
{
cout << "A(const A& aa)" << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
A* p1 = (A*)malloc(sizeof(A) * 4);
A* p2 = new A[4]{1,2,3,4};
free(p1);
delete[] p2;
return 0;
}
从上面样例可以看到，new自定义类型对象的时候，会去调用它的构造函数。当然这里是以整型值初始化自定义类型，会产生隐式类型转换，因为是在同一行编译器自动进行了优化，所以没有调用拷贝构造函数。而malloc只是单纯地开空间。delete自定义类型对象时，会去调用他的析构函数，而free只是单纯释放空间。
4.1.c++和c语言在开辟动态内存时失败处理细节
在C语言中，当使用malloc()函数开辟动态内存时，如果内存不足或者没有足够的连续空间，函数将返回NULL指针，表示内存分配失败。而在C++中，使用new操作符开辟动态内存时，如果内存不足或者没有足够的连续空间，将抛出一个std::bad_alloc异常，表示内存分配失败。
//C语言
int main()
{
int* p1 = (int*)malloc(sizeof(int) * 1024);
if (p1 == NULL)
{
perror("malloc fail");
exit(-1);
}
return 0;
}
//C++
int main()
{
int* p1 = nullptr;
try
{
do
{
p1 = new int[1024];
cout << p1 << endl;
} while (p1);
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
在面向对象的编程语言的编程中，try-catch是一种异常处理机制。在try块中，我们编写可能引发异常的代码。如果在try块中的代码引发了异常，程序会立即跳转到与其对应的catch块。catch块定义了异常处理程序，它会处理try块中引发的异常。这里稍微了解即可，具体细节得等到后面学习后再和大家介绍了。
5.new和delete的原理
5.1.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申请空间成功时直接返回；申请空间失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
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;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)
operator delete：通过调用free来释放空间，而且operator delete和宏函数free的底层都是调用_free_dbg来进行释放空间的
5.2.operator new、new、operator delete和delete函数的底层实现
首先，通过下面代码的汇编代码来看看operator new、new、operator delete和delete函数究竟是怎么样的吧。
class A
{
public:
A(int a = 0,int b = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
A(const A& aa)
{
cout << "A(const A& aa)" << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
A* p1 = (A*)operator new(sizeof(A));
A* p2 = new A(1,1);
operator delete(p1);
delete p2;
return 0;
}
通过查看汇编代码我们可以看到，new的会先调用operator new开辟空间，然后在调用构造函数初始化。delete会先调用析构函数进行清理，然后调用operator delete来释放动态内存。当然用new 自定义类型[N] 个对象，会先调用operator new开辟空间，然后在调用N次构造函数初始化。delete[] 会先调用N次析构函数，然后释放动态内存。
下面通过一个比较复杂的场景来看一下new和delete对于自定义类的的处理
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 3)
{
cout << "Stack(size_t capacity = 3)" << endl;
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~Stack()
{
cout << "~Stack()" << endl;
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
Stack* p1 = new Stack;
delete p1;
return 0;
}
6.定位new
定位new是new关键字的另一种用法，用于给已经分配好的堆区空间进行调用构造函数来初始化对象。
6.1.代码样例演示
class A
{
public:
A(int a = 0,int b = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
A(const A& aa)
{
cout << "A(const A& aa)" << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
A* p1 = (A*)malloc(sizeof(A));
new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
p1->~A();//显示调用析构函数
free(p1);
return 0;
}
6.2.定位new的应用场景
在一些需要频繁申请堆区内存的程序中，通常需要提前开辟一个内存池，用于提高获取堆区内存的效率。而定位new就能将申请的内存通过调用构造函数来进行初始化。在后面学习的STL的链表中就能遇到这一场景。
7. malloc/free和new/delete的区别
1、malloc/free是库函数。new和delete是操作符。
2、对于内置类型来说malloc/free和new/delete的区别不是很大，对于自定义类型new/delete分别会去调用构造函数/析构函数。来进行初始化和清理工作。
3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可。
4. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常。
8.内存泄漏的概念
8.1.什么是内存泄漏
内存泄漏指的是在程序运行过程中，程序分配了一段内存空间，但在使用完这段内存空间后，没有及时释放掉这段内存，导致这段内存不能被再次使用，从而造成了内存空间的浪费。如果程序中存在内存泄漏问题，并且这种泄漏的情况不断累积，最终可能会导致程序所能使用的内存空间越来越小，甚至导致程序崩溃。内存泄漏是一种常见的编程错误，需要开发人员注意及时释放不再使用的内存空间，避免内存泄漏问题的出现。下面我通过一个样例来看看内存。
int main()
{
char* p1 = (char*)malloc(1024 * 1024 * 1024);
cout << p1 << endl;
return 0;
}
8.2.内存泄漏的危害
对于客户端，内存泄漏的危害比较的小。对于服务端，内存泄漏的危害极大。因为想游戏服务、电商服务等服务端中，内存泄漏会导致服务程序宕机，进而导致软件业务的事故。所以我们程序员在操作动态内存时，一定要注意在哪里申请了就在对应的位置释放。内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。