C++内存管理

2023-10-03 08:17:52

1. C++内存分配方式

内存分配方式有三种：

从静态存储区域分配(static)。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。
从堆上分配（new/delete），亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。
在栈上创建(局部变量)。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

2. 常见的内存错误

发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。

2.1 内存分配未成功，却使用了它

编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。常用解决办法是，在使用内存之前检查指针是否为NULL。如果指针p是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存，应该用if(p==NULL) 或if(p!=NULL)进行防错处理。

2.2 内存分配虽然成功，但是尚未初始化就引用它

犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误（例如数组）。内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。所以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦。

2.3 内存分配成功并且已经初始化，但操作越过了内存的边界

例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for循环语句中，循环次数很容易搞错，导致数组操作越界。

2.4 忘记了释放内存，造成内存泄露

含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则肯定有错误（new/delete同理）。

2.5 释放了内存却继续使用它

有三种情况：

（1）程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。

（2）函数的return语句写错了，注意不要返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁。

（3）使用free或delete释放了内存后，没有将指针设置为NULL。导致产生“野指针”。

3. 注意事项

① 用malloc或new申请内存之后，应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存。

② 不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。

③ 避免数组或指针的下标越界，特别要当心发生“多1”或者“少1”操作。

④ 动态内存的申请与释放必须配对，防止内存泄漏。

⑤ 用free或delete释放了内存之后，立即将指针设置为NULL，防止产生“野指针”。

4. 指针传递内存

如果函数的参数是一个指针，不要指望用该指针去申请动态内存。下面示例中，Test函数的语句GetMemory(str, 200)并没有使str获得期望的内存，str依旧是NULL，为什么？

void GetMemory(char *p, int num)
{
	p = (char *)malloc(sizeof(char) * num);
}

void Test(void)
{
	char *str = NULL;
	GetMemory(str, 100);	// str 仍然为 NULL	
	strcpy(str, "hello");	// 运行错误
}

用指针参数申请动态内存

问题出在函数GetMemory中。编译器总是要为函数的每个参数制作临时副本，指针参数p的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p的内容，就导致参数p的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中，_p申请了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变。所以函数GetMemory并不能输出任何东西。事实上，每执行一次GetMemory就会泄露一块内存，因为没有用free释放内存。

解决方法一：（指向指针的指针）

如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”：

void GetMemory2(char **p, int num)
{
	*p = (char *)malloc(sizeof(char) * num);
}

void Test2(void)
{
	char *str = NULL;
	GetMemory2(&str, 100);	// 注意参数是 &str，而不是str
	strcpy(str, "hello");	
	cout<< str << endl;
	free(str);	
}

用指向指针的指针申请动态内存

解决方法二：（函数返回值）

我们可以用函数返回值来传递动态内存：

char *GetMemory3(int num)
{
	char *p = (char *)malloc(sizeof(char) * num);
	return p;
}

void Test3(void)
{
	char *str = NULL;
	str = GetMemory3(100);	
	strcpy(str, "hello");
	cout<< str << endl;
	free(str);	
}

用函数返回值申请动态内存

此处强调不要用return语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消亡。

5. 野指针

“野指针”不是NULL指针，是指向“垃圾”内存的指针。人们一般不会错用NULL指针，因为用if语句很容易判断。但是“野指针”是很危险的，if语句对它不起作用。

“野指针”的成因主要有两种：

（1）指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。例如

char *p = NULL;
char *str = (char *) malloc(100);

（2）指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。

看下面一段代码：

char *p = (char *) malloc(100);
	strcpy(p, “hello”);
	free(p);	    // p 所指的内存被释放，但是p所指的地址仍然不变
	…
	if(p != NULL)	// 没有起到防错作用
	{
	   strcpy(p, “world”);	// 出错
}

指针p被free以后其地址仍然不变（非NULL），只是该地址对应的内存是垃圾，p成了“野指针”。如果此时不把p设置为NULL，会让人误以为p是个合法的指针。

如果程序比较长，我们有时记不住p所指的内存是否已经被释放，在继续使用p之前，通常会用语句if (p != NULL)进行防错处理。很遗憾，此时if语句起不到防错作用，因为即便p不是NULL指针，它也不指向合法的内存块。

free()和delete(）只是把指针所指的内存给释放掉，但并没有把指针本身干掉。

上面代码中的指针p就是野指针。

（3）指针操作超越了变量的作用范围。这种情况让人防不胜防，示例程序如下：

class A 
{	
public:
	void Func(void){ cout << “Func of class A” << endl; }
};

void Test(void)
{
	A  *p;
	{
		A  a;
		p = &a;	// 注意 a 的生命期
    }
	
    p->Func();		// p是“野指针”
}

函数Test在执行语句p->Func()时，对象a已经消失，而p是指向a的，所以p就成了“野指针”。但奇怪的是我运行这个程序时居然没有出错，这可能与编译器有关。

6. malloc/free 与new/delete区别

malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。

对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。

因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。

class Obj
{
public :
	Obj(void){ cout << “Initialization” << endl; }
    ~Obj(void){ cout << “Destroy” << endl; }
    
    void Initialize(void){ cout << “Initialization” << endl; }
    void Destroy(void){ cout << “Destroy” << endl; }
};

void UseMallocFree(void)
{
	Obj  *a = (obj *)malloc(sizeof(obj));	// 申请动态内存
	a->Initialize();						// 初始化
	//…
	a->Destroy();	                       // 清除工作
	free(a);		                       // 释放内存
}

void UseNewDelete(void)
{
	Obj  *a = new Obj;	                  // 申请动态内存并且初始化
	//…
	delete a;			                  // 清除并且释放内存
}

用malloc/free和new/delete如何实现对象的动态内存管理

类Obj的函数Initialize模拟了构造函数的功能，函数Destroy模拟了析构函数的功能。函数UseMallocFree中，由于malloc/free不能执行构造函数与析构函数，必须调用成员函数Initialize和Destroy来完成初始化与清除工作。函数UseNewDelete则简单得多。

所以我们不要企图用malloc/free来完成动态对象的内存管理，应该用new/delete。由于内部数据类型的“对象”没有构造与析构的过程，对它们而言malloc/free和new/delete是等价的。

既然new/delete的功能完全覆盖了malloc/free，为什么C++不把malloc/free淘汰出局呢？这是因为C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。

如果用free释放“new创建的动态对象”，那么该对象因无法执行析构函数而可能导致程序出错。如果用delete释放“malloc申请的动态内存”，理论上讲程序不会出错，但是该程序的可读性很差。所以new/delete必须配对使用，malloc/free也一样。

6.1 函数malloc的原型

void * malloc(size_t size);

用malloc申请一块长度为length的整数类型的内存，程序如下：

int *p = (int *) malloc(sizeof(int) * length);

我们应当把注意力集中在两个要素上：“类型转换”和“sizeof”。

1.malloc返回值的类型是void *，所以在调用malloc时要显式地进行类型转换，将void * 转换成所需要的指针类型。

2. malloc函数本身并不识别要申请的内存是什么类型，它只关心内存的总字节数。

6.2 函数free的原型

void free( void * memblock );

为什么free函数不象malloc函数那样复杂呢？这是因为指针p的类型以及它所指的内存的容量事先都是知道的，语句free(p)能正确地释放内存。如果p是NULL指针，那么free对p无论操作多少次都不会出问题。如果p不是NULL指针，那么free对p连续操作两次就会导致程序运行错误。

6.3 new/delete

运算符new使用起来要比函数malloc简单得多，例如：

int  *p1 = (int *)malloc(sizeof(int) * length);
int  *p2 = new int[length];

这是因为new内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言，new在创建动态对象的同时完成了初始化工作。如果对象有多个构造函数，那么new的语句也可以有多种形式。例如

class Obj

{

public :

    Obj(void);      // 无参数的构造函数

    Obj(int x);     // 带一个参数的构造函数

…

}

void Test(void)

{

    Obj  *a = new Obj;

    Obj  *b = new Obj(1);   // 初值为1

    …

    delete a;

    delete b;

}

如果用new创建对象数组，那么只能使用对象的无参数构造函数。例如

 Obj  *objects = new Obj[100];   // 创建100个动态对象

不能写成

Obj *objects = new Obj[100](1);// 创建100个动态对象的同时赋初值1

在用delete释放对象数组时，留意不要丢了符号‘[]’。例如

  delete []objects;   // 正确的用法

delete objects; // 错误的用法

后者相当于delete objects[0]，漏掉了另外99个对象。

码农公寓