首页 > 系统相关> 文章详细

C++内存管理

2021-12-17 11:58:57 阅读：128 来源： 互联网

标签：malloc 管理 C++ free 内存 new NULL 指针

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个对象。

标签：malloc,管理,C++,free,内存,new,NULL,指针
来源： https://blog.csdn.net/zhangchuan7758/article/details/121907147

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9