C++入门篇，内存管理_c++ new int

C++入门篇——内存管理

本节介绍C/C++的内存分布，介绍C和C++中动态内存管理，并介绍之间的区别，介绍new和delete关键字的实现原理和定位new表达式。

1 C/C++内存分布

[说明]

1. 栈又称为堆栈，通常会将非静态的局部变量，函数参数，返回值等等放入其中，是向下增长的。
2. 内存映射段是用于装载一个共享的动态内存库。这里不过多介绍。
3. 堆是程序运行时的内存分配，通常区域很大，使用malloc或者new都会在这开辟空间，是向上增长的。
4. 数据段，是用来存储全局数据和静态数据的。
5. 代码段，是用来存储可执行代码以及只读常量。

2 C语言中动态内存管理方式：malloc/calloc/realloc/free

2.1 malloc

malloc是用来在堆区开辟一块空间供程序使用，如果成功，会返回一个指向这个空间的指针，如果返回失败，则返回空。

语法：void* malloc (size_t size);

头文件：#include <stdlib.h>

使用：

int* p1 = (int*) malloc(sizeof(int));
1

2.2 calloc

calloc与malloc相似，并且在开辟空间后，自动为空间内的元素初始化为0。

语法：void* calloc (size_t num, size_t 大小);

头文件：#include <stdlib.h>

使用：

int* p2 = (int*)calloc(4, sizeof (int));
1

2.3 realloc

realloc是改变已有的堆空间大小，并返回指向这块新空间的指针。

语法：void* realloc (void* ptr, size_t size);

头文件：#include <stdlib.h>

使用：

int* p3 = (int*)realloc(p2, sizeof(int)*10);
1

2.4 free

free是用来释放已有的堆空间，还给操作系统。

语法：void free (void* ptr);

头文件：#include <stdlib.h>

使用：

free(p1);
free(p3);
1
2

3 C++内存管理方式

3.1 new/delete 操作内置类型

new/delete是C++的关键字，其实本质上也是进行堆内存的开辟和释放。下面介绍它的用法：

语法：new 类型 / new 类型[数组大小] delete 指向堆内存的指针 / delete[] 指向堆内存指针的数组

使用：

int main()
{
    // 动态申请一个int类型的空间
    int* ptr4 = new int;
    // 动态申请一个int类型的空间并初始化为10
    int* ptr5 = new int(10);
    // 动态申请10个int类型的空间
    int* ptr6 = new int[3];
    delete ptr4;
    delete ptr5;
    delete[] ptr6;
}
1
2
3
4
5
6
7
8
9
10
11
12

new 可以针对内置类型进行初始化，需要在类型后加一个括号，并放入初始化的值。这里用new创建的数组，必须要用对应delete[]的方式进行释放，否则可能会出错。

3.2 new/delete 操作自定义类型

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;
	// 内置类型是几乎是一样的
	int* p3 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int;
	free(p3);
	delete p4;
	A* p5 = (A*)malloc(sizeof(A) * 10);
	A* p6 = new A[10];
	free(p5);
	delete[] p6;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

针对自定义类型，new和delete都会调用对应类型的构造函数和析构函数，这和malloc和free的区别在于，C语言的malloc和free不会去调用自定义类型的构造函数和析构函数。

4 operator new与operator delete函数

new和delete是用户进行内存申请和释放的关键字，而operator new 和operator delete是系统提供的全局函数，其实，new和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 delete: 该函数最终是通过free来释放空间的
*/
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

其实，这里有很多，我们看不懂的，但是，我们知道operator new本质上还是去调用C语言的malloc函数，并且对于malloc函数的返回值进行了处理， 它是通过抛异常的方式，如果malloc内存不够了，会再去看看还有没有可以在用的空间，如果没有，就会抛出异常。

虽然，我们在operator delete没有看到free函数，但其实free函数也是对于_free_dbg这个函数的封装，_free_dbg这个函数会对于我们传进去的指针进行内存释放。并且operator delete 还做了一系列处理。

#define free(p)     _free_dbg(p, _NORMAL_BLOCK)
1

那么，针对于operator new 和operator delete这两个函数是可以进行重载的，也就是说，我们在编写一个自定义类的时候，可以实现一个专属的new和delete的版本。

class A
{
public:
	A(int a) : _a(a) {}

	void *operator new(size_t size)
	{
		void* p = ::operator new(size);
		cout << "operator new(size_t size)" << endl;
		return p;
	}
	void operator delete(void* p)
	{
		cout << "operator delete(void* p)" << endl;
		::operator delete(p);
	}
private:
	int _a;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5 new和delete的实现原理

5.1 内置类型

如果申请的是内置类型的空间，new和malloc，delete和free类似，不同的地方在于，new申请的失败的时候是抛异常，而malloc是返回NULL，并且new可以进行初始化，而C语言虽然有calloc，但是只能初始化为0。

5.2 自定义类型

• new的原理
  1. 调用operator new函数申请空间
  2. 在申请的空间上执行构造函数
• delete的原理
  1. 在空间上执行析构函数，完成对象中资源的清理。
  2. 调用operator delete来释放对象的空间
• new T[N]的原理
  1. 调用operator new[]函数，来完成对N个对象空间的申请
  2. 并且执行N次的构造函数
• delete[]的原理
  1. 在释放对象空间，执行N次析构函数，完成N个对象资源清理。
  2. 调用operator delete[]释放空间。

6 定位new表达式(placement-new)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

我们有的时候，在进行new创建对象后，发现想要对已有的这个对象进行初始化，就可以使用这个表达式。

语法：new(已分配的堆空间的指针)类型(初始化值)

int main()
{
	int* p = new int;
	cout << *p << endl; // 随机值
	new(p)int(3);
	cout << *p << endl; // 3
}
1
2
3
4
5
6
7