c++内存管理

目录

1.内存分配模式简介

2.明确区分堆和栈

3堆和栈有什么不同

2控制c++的内存分配

2.1重载全局的new和delete操作符

2.2为单个的类重载new[ ]和delete[ ]

3常见的内存错误极其对策

1.3.1 内存分配未成功，却使用啦

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

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

3.4 释放了内存却继续使用它。

3.5解决规则

4数组和指针的对比

4.1修改内容

4.2 内容复制与比较

4.3 计算内存容量

5 指针参数是如何传递内存的？

6杜绝野指针

7 有了malloc/free为什么还要new/delete？

8内存耗尽怎么办

9new/delete的使用要点

---

1.内存分配模式简介

在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区

 栈：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限

堆：就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收

 自由存储区：就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。

全局/静态存储区：全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区

常量存储区：这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改。

2.明确区分堆和栈

void f() { int* p=new int[5]; }

 这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存

这一句话的含义：在栈内存中存放了一个指向一块堆内存的指针p

　这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。

3堆和栈有什么不同

主要有：

1、管理方式不同；

对于栈来讲，是由编译器自动管理，无需我们手工控制；

对于堆来说，释放工作由程序员控制，容易产生memory leak。

2、空间大小不同；

一般来讲在32位系统下，堆内存可以达到4G的空间

栈来讲，一般都是有一定的空间大小的（可修改）

当然，我们可以修改：打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。

3、能否产生碎片不同；

对于堆来讲：频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低

对于栈来讲：则不会存在这个问题，因为栈是先进后出的队列

4、生长方向不同；

对于堆来讲：生长方向是向上的，也就是向着内存地址增加的方向；

对于栈来讲：它的生长方向是向下的，是向着内存地址减小的方向增长。

5、分配方式不同；

堆都是动态分配的，没有静态分配的堆

有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，

比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，

他的动态分配是由编译器进行释放，无需我们手工实现。

6、分配效率不同；

栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高

堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。

2控制c++的内存分配

但当你必须要使用new 和delete时，你不得不控制C++中的内存分配。你需要用一个全局的new 和delete来代替系统的内存分配符，并且一个类一个类的重载new 和delete。

2.1重载全局的new和delete操作符

void * operator new(size_t size)
 
{
 
void *p = malloc(size);
 
return (p);
 
}
 
void operator delete(void *p);
 
{
 
free(p);
 
} 

这段代码可以代替默认的操作符来满足内存分配的请求。出于解释C++的目的，我们也可以直接调用malloc() 和free()。

class TestClass {
 
public:
 
void * operator new(size_t size);
 
void operator delete(void *p);
 
// .. other members here ...
 
};
 
void *TestClass::operator new(size_t size)
 
{
 
void *p = malloc(size); // Replace this with alternative allocator
 
return (p);
 
}
 
void TestClass::operator delete(void *p)
 
{
 
free(p); // Replace this with alternative de-allocator
 
}

2.2为单个的类重载new[ ]和delete[ ]

必须小心对象数组的分配。你可能希望调用到被你重载过的new 和 delete 操作符，但并不如此。内存的请求被定向到全局的new[ ]和delete[ ] 操作符，而这些内存来自于系统堆。

C++将对象数组的内存分配作为一个单独的操作，而不同于单个对象的内存分配。为了改变这种方式，你同样需要重载new[ ] 和 delete[ ]操作符。

class TestClass {
 
public:
 
void * operator new[ ](size_t size);
 
void operator delete[ ](void *p);
 
// .. other members here ..
 
};
 
void *TestClass::operator new[ ](size_t size)
 
{
 
void *p = malloc(size);
 
return (p);
 
}
 
void TestClass::operator delete[ ](void *p)
 
{
 
free(p);
 
}
 
int main(void)
 
{
 
TestClass *p = new TestClass[10];
 
// ... etc ...
 
delete[ ] p;
 
} 

对于多数C++的实现，new[]操作符中的个数参数是数组的大小加上额外的存储对象数目的一些字节

3常见的内存错误极其对策

发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。有时用户怒气冲冲地把你找来，程序却没有发生任何问题，你一走，错误又发作了。 常见的内存错误及其对策如下：

1.3.1 内存分配未成功，却使用啦

编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。常用解决办法是，在使用内存之前检查指针是否为NULL。

如果指针p是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。

如果是用malloc或new来申请内存，应该用if(p==NULL) 或if(p!=NULL)进行防错处理。

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

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

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

含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。

动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则肯定有错误（new/delete同理）。

3.4 释放了内存却继续使用它。

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

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

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

3.5解决规则

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

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

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

【规则4】动态内存的申请与释放必须配对，防止内存泄漏。

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

4数组和指针的对比

C++/C程序中，指针和数组在不少地方可以相互替换着用，让人产生一种错觉，以为两者是等价的。

数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。数组名对应着（而不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。

指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。指针远比数组灵活，但也更危险。

4.1修改内容

下面示例中，字符数组a的容量是6个字符，其内容为hello。a的内容可以改变，如a[0]= ‘X’。

指针p指向常量字符串“world”（位于静态存储区，内容为world），常量字符串的内容是不可以被修改的。从语法上看，编译器并不觉得语句p[0]= ‘X’有什么不妥，但是该语句企图修改常量字符串的内容而导致运行错误。

char a[] = “hello”;
 
a[0] = ‘X’;
 
cout << a << endl;
 
char *p = “world”; // 注意p指向常量字符串
 
p[0] = ‘X’; // 编译器不能发现该错误
 
cout << p << endl;

4.2 内容复制与比较

不能对数组名进行直接复制与比较。若想把数组a的内容复制给数组b，不能用语句 b = a ，否则将产生编译错误。应该用标准库函数strcpy进行复制。同理，比较b和a的内容是否相同，不能用if(b==a) 来判断，应该用标准库函数strcmp进行比较。

语句p = a 并不能把a的内容复制指针p，而是把a的地址赋给了p。要想复制a的内容，可以先用库函数malloc为p申请一块容量为strlen(a)+1个字符的内存，再用strcpy进行字符串复制。同理，语句if(p==a) 比较的不是内容而是地址，应该用库函数strcmp来比较。

// 数组…
 
char a[] = "hello";
 
char b[10];
 
strcpy(b, a); // 不能用 b = a;
 
if(strcmp(b, a) == 0) // 不能用 if (b == a)
 
…
 
// 指针…
 
int len = strlen(a);
 
char *p = (char *)malloc(sizeof(char)*(len+1));
 
strcpy(p,a); // 不要用 p = a;
 
if(strcmp(p, a) == 0) // 不要用 if (p == a)

4.3 计算内存容量

用运算符sizeof可以计算出数组的容量（字节数）。如下示例中，sizeof(a)的值是12（注意别忘了’’）。指针p指向a，但是sizeof(p)的值却是4。这是因为sizeof(p)得到的是一个指针变量的字节数，相当于sizeof(char*)，而不是p所指的内存容量。C++/C语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。

char a[] = "hello world";
 
char *p = a;
 
cout<< sizeof(a) << endl; // 12字节
 
cout<< sizeof(p) << endl; // 4字节

注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。如下示例中，不论数组a的容量是多少，sizeof(a)始终等于sizeof(char *)。

void Func(char a[100])
 
{
 
　cout<< sizeof(a) << endl; // 4字节而不是100字节
 
}

5 指针参数是如何传递内存的？

如果函数的参数是一个指针，不要指望用该指针去申请动态内存。如下示例中，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);
 
}

副本为**_p   *p指向**_p  *p改变啦，所以**p也改变

 由于“指向指针的指针”这个概念不容易理解，我们可以用函数返回值来传递动态内存。这种方法更加简单，见示例：

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);
 
}

6杜绝野指针

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

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

char *p = NULL;

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

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

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

lass A
 
{
 
　public:
 
　　void Func(void){ cout << “Func of class A” << endl; }
 
};
 
void Test(void)
 
{
 
　A *p;
 
　{
 
　　A a;
 
　　p = &a; // 注意 a 的生命期
 
　}
 
　p->Func(); // p是“野指针”
 
}

7 有了malloc/free为什么还要new/delete？

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

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

 因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。我们先看一看malloc/free和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; // 清除并且释放内存
 
}

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

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

8内存耗尽怎么办

（1）判断指针是否为NULL，如果是则马上用return语句终止本函数。例如：

void Func(void)
 
{
 
　A *a = new A;
 
　if(a == NULL)
 
　{
 
　　return;
 
　}
 
　…
 
}

（2）判断指针是否为NULL，如果是则马上用exit(1)终止整个程序的运行。例如：

void Func(void)
 
{
 
　A *a = new A;
 
　if(a == NULL)
 
　{
 
　　cout << “Memory Exhausted” << endl;
 
　　exit(1);
 
　}
 
　…
 
}

（3）为new和malloc设置异常处理函数。例如Visual C++可以用_set_new_hander函数为new设置用户自己定义的异常处理函数，也可以让malloc享用与new相同的异常处理函数。详细内容请参考C++使用手册。

有一个很重要的现象要告诉大家。对于32位以上的应用程序而言，无论怎样使用malloc与new，几乎不可能导致“内存耗尽”

9new/delete的使用要点

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创建对象数组，那么只能使用对象的无参数构造函数。例如：

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

 不能写成：

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

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

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

delete objects; // 错误的用法