https://blog.csdn.net/liuyuchen282828/article/details/89255389（内存和数据结构：堆栈）
https://blog.csdn.net/qq_27825451/article/details/102572636（数据结构：堆栈）
https://blog.csdn.net/qq_27825451/article/details/102572795（内存堆和内存栈）
https://blog.csdn.net/u011825004/article/details/104214095（目前看到最全面包含Linux）
https://blog.csdn.net/juicy_w/article/details/80044767（free bug问题总结）
https://www.cnblogs.com/xiao0913/p/4354119.html（是否初始化）
内存管理是C++最令人切齿痛恨的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对C++的痛恨，但内存管理在C++中无处不在，内存泄漏几乎在每个C++程序中都会发生，因此要想成为C++高手，内存管理一关是必须要过的，除非放弃C++，转到Java或者.NET，他们的内存管理基本是自动的，当然你也放弃了自由和对内存的支配权，还放弃了C++超绝的性能。
伟大的Bill Gates 曾经失言：
640K ought to be enough for everybody — Bill Gates 1981
程序员们经常编写内存管理程序，往往提心吊胆。如果不想触雷，唯一的解决办法就是发现所有潜伏的地雷并且排除它们，躲是躲不了的。
内存分配方式
简介
在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
栈：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
堆：就是那些由 new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个 delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
自由存储区：就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
全局/静态存储区：全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
常量存储区：这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改。
（也可分为1）栈2）堆（new和malloc合一起）3）静态存储区4) 文字常量分配在文字常量区，程序结束后由系统释放。5）程序代码区。 存放函数体的二进制代码。）
|----------------------| 高地址
| 栈区(Statk) | -->向下增长
|----------------------|
| 堆区(Heap) | -->向上增长
|----------------------|
| 未初始化(BSS) |
|----------------------|
| 初始化(Data) |
|----------------------|
| 常量存储区(RODATA) |
|----------------------|
| 正文段(Text) |
|----------------------| 低地址
内存分区:
堆: 由程序员手动分配和释放，完全不同于数据结构中的堆，分配方式类似链表。若程序中程序员不释放，程序结束后由系统释放。
栈: 由编译器自动分配和释放，存放函数的参数、局部变量的值，操作方式类似于数据结构中的栈。
静态区: 存放全局变量和静态变量，包括DATA段(全局初始化区)和BSS段(全局未初始化区)，程序结束后由系统释放。
文字常量区(rodata):也就是read only，只读数据段。常量字符串就是放在这里的，程序结束后由系统释放。
代码区: 存放函数体的二进制代码。
例子
int a = 0;
char* p1;
void main()
{
int b;
char s[] = "abc";
char* p2;
char* p3 = "123456";
static int c = 0;
p1 = (char*)malloc(10);
p2 = (char*)malloc(20)
}以上，第一个变量a存储在全局区，已初始化，也就是DATA段
第二个变量p1存储在全局区，未初始化，BSS段
第三个变量b栈区
第四个变量第五个第六个都在栈区，字符串常量存储在文字常量区
第七个静态变量存储在静态区，DATA段
由malloc分配的存储在堆区
分类：
简单的介绍一下四个区域：
（1）代码区--------主要存储程序代码指令，define定义的常量。
（2）全局数据区------主要存储全局变量（常量），静态变量（常量），常量字符串。
（3）栈区--------主要存储局部变量，栈区上的内容只在函数范围内存在，当函数运行结束，这些内容也会自动被销毁。其特点是效率高，但内存大小有限。
（4）堆区--------由malloc,calloc分配的内存区域，其生命周期由free决定。堆的内存大小是由程序员分配的，理论上可以占据系统中的所有内存。
5分类：
1.栈又叫堆栈，非静态局部变量/函数参数/返回值等等 ，还有每次调用函数时保存的信息。每当调用一个函数时，返回到的地址和关于调用者环境的某些信息的地址，比如一些机器寄存器，就会被保存在栈中。然后，新调用的函数在栈上分配空间，用于自动和临时变量。
2.内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。
3.堆用于程序运行时动态内存分配，堆是可以上增长的。堆区域从BSS段的末尾开始，并从那里逐渐增加到更大的地址。堆是由程序员自己分配的。堆区域由所有共享库和进程中动态加载的模块共享。
4.数据段分为初始化数据段和未初始化数据段。初始化的数据段，通常称为数据段，是程序的虚拟地址空间的一部分，它包含有程序员初始化的全局变量和静态变量，可以进一步划分为只读区域和读写区域。未初始化的数据段，通常称为bss段，这个段的数据在程序开始之前有内核初始化为0，包含所有初始化为0和没有显示初始化的全局变量和静态变量。
5.代码段也叫文本段，是对象文件或内存中程序的一部分，其中包含可执行代码和只读常量。文本段在堆栈的下面，是防止堆栈溢出覆盖它。，通常代码段是共享的，对于经常执行的程序，只有一个副本需要存储在内存中，代码段是只读的，以防止程序以外修改指令。
函数调用后返回地址——保存在栈内存上
函数调用时通过一个指向函数的指针指向函数，函数返回时将回归到调用处，那个地方就是函数调用结束后返回地址
另外返回地址保存在栈上，最先调用的函数最早入栈，最后出栈，而最后调用的函数最后入栈，最先出栈。
明确区分堆与栈
堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。
首先，我们举一个例子：
|
1
|
void f() { int* p=new int[5]; }
|
这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：
00401028 push 14h
0040102A call operator new (00401060)
0040102F add esp,4
00401032 mov dword ptr [ebp-8],eax
00401035 mov eax,dword ptr [ebp-8]
00401038 mov dword ptr [ebp-4],eax
这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，编译器就会根据相应的Cookie信息去进行释放内存的工作。
堆和栈究竟有什么区别
好了，我们回到我们的主题：堆和栈究竟有什么区别？
主要的区别由以下几点：
- 管理方式不同：栈内数据由编译器自动管理，而堆内数据须手动释放；
- 空间大小不同：栈空间往往较小，而堆空间往往较大，在常见情况下，栈的大小为1MB，而堆可达到4GB；
- 是否产生碎片：由于采用了LIFO的数据存储策略，栈的利用率相当高，几乎不会产生内存碎片；反观堆，多次的手动申请、释放非常容易产生内存碎片，造成堆空间的不连续；
- 生长方向不同：栈从高地址向低地址生长，堆从低地址向高地址生长；
- 分配方式不同：栈上空间可以静态分配，也可以动态分配(其实就是特指placement new，或者说得更深就是使用alloca()函数，由编译器进行释放)，堆上空间只可以进行动态分配；
- 分配效率不同：栈的操作有系统底层支持，有专门的指令进行进栈和出栈的操作，相比之下，堆的操作由C/C++的库函数提供，机制复杂，需要多次嵌套，效率相比栈要低很多。
关于内存栈（memory stack）
栈溢出
“栈”由程序自动向操作系统申请分配以及回收，速度快，使用方便，但程序员无法控制。但是栈的空间很小，只要栈的剩余空间大于所申请空间，系统将为程序提供内存，若需要分配的空间大于栈内存，则分配失败，则提示栈溢出错误。
#include <iostream>
int main()
{
int i = 10; //变量i储存在栈区中
const int i2 = 20; //const局部变量也存储在stack
int i3 = 30;
std::cout << &i << " " << &i2 << " " << &i3 << std::endl;
return 0;
}
/*运行结果为：
0x28fedc 0x28fed8 0x28fed4 16进制地址，递减的
*/注意：const局部变量也储存在栈区内，栈区向地址减小的方向增长。
栈的特性
（1）申请大小的限制
在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 Windows下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
（2）栈的申请效率很高
栈由系统自动分配，速度较快。但程序员是无法控制的，结束后由操作系统进行释放。
（3）栈使用的过程
栈在函数调用时，
- 第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，
- 然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，
- 然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
C,C++在传递数组的时候传递的是地址或者是引用原因
从上面的分析可以知道，由于函数的参数存储在栈内存中，所以如果一个数组比较大，传递一个很大的数组，如果复制的是数组的值到形参上面，必然会导致栈内存不够用，即“栈溢出”，所以只传递一个地址值，而不传递实际的值就可以避免这一问题，其实向java，C#这些语言也有着相同的底层原理，后面继续说明。
总结：
我们在C语言里面函数的参数传递经常分为，值传递/指针传递
在C#，Java，C++里面函数的参数传递我们经常分为，值传递/引用传递
其实从内存的“栈内存”角度来说，所有的函数参数传递都只有一种形式，那就是值传递。
因为如果参数是值，则会拷贝栈里面的值到函数的形参里面去，这当然是值传递了，
如果参数是地址或者是引用，其实同样是会拷贝存在在栈区域里面的地址或者是引用传递到函数形参，只不过这个地址或者是引用不是真正的数据，拷贝的那个相同的地址或者谁引用会指向同一段数据，所以我们称之为传递引用或者是地址。
总而言之：传递地址或者是引用只是表面，本质都是“值传递”。
关于内存堆（memory heap）
堆溢出
堆是向高地址扩展的数据结构，是不连续的内存区域，这是由于系统使用链表存储空闲内存地址的（windows？），自然是不连续的。而链表的遍历方式是由低地址向高地址，堆的大小受限于计算机系统中有效的内存，由此可见，堆获得的空间比较灵活，也比较大。
程序员向操作系统申请一块内存，当系统收到程序的申请时，会遍历一个记录空闲内存地址的链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。分配的速度较慢，地址不连续，容易碎片化。此外，由程序员申请，同时也必须由程序员负责销毁，否则导致内存泄露。
堆的特性
操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。
（1）申请大小的限制
堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的物理内存。由此可见，堆获得的空间比较灵活，也比较大。
（2）堆的使用效率
堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。
（3）堆使用的过程
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。
设计一个只能在堆上/栈上创建对象的类
只在堆上
只在堆上创建对象，做法就是将在栈上对象或者在栈上分配的方法屏蔽即可，因此只需要将构造函数私有化即可：
#include<iostream>
using namespace std;
class Heap_Only
{
public: //Make member function public
static void *Create()
{
return new Heap_Only;
}
private: //Make constructor private
Heap_Only()
{
}
Heap_Only(const Heap_Only&)
}
int main()
{
Heap_Only *p = Heap_Only::Create();
return 0;
}
只在栈上
只在栈上创建类时，只需屏蔽动态分配即可，因此将operator new 和 operator delete 私有化
#include<iostream>
using namespace std;
class Stack_Only
{
public:
Stack_Only();
~Stack_Only();
private:
void *operator new (size_t);
void *operator delete (void *);
}
int main()
{
Stack_Only p;
return 0;
}
控制C++的内存分配
在嵌入式系统中使用C++的一个常见问题是内存分配，即对new 和 delete 操作符的失控。
具有讽刺意味的是，问题的根源却是C++对内存的管理非常的容易而且安全。具体地说，当一个对象被消除时，它的析构函数能够安全的释放所分配的内存。
这当然是个好事情，但是这种使用的简单性使得程序员们过度使用new 和 delete，而不注意在嵌入式C++环境中的因果关系。并且，在嵌入式系统中，由于内存的限制，频繁的动态分配不定大小的内存会引起很大的问题以及堆破碎的风险。
作为忠告，保守的使用内存分配是嵌入式环境中的第一原则。
但当你必须要使用new和delete时，你不得不控制C++中的内存分配。你需要用一个全局的new 和delete来代替系统的内存分配符，并且一个类一个类的重载new和delete。
一个防止堆破碎的通用方法是从不同固定大小的内存持中分配不同类型的对象。对每个类重载new 和delete就提供了这样的控制。
重载全局的new和delete操作符
可以很容易地重载new 和 delete 操作符，如下所示:
|
1
2
3
4
5
6
7
8
|
void * operator new(size_t size){
void *p = malloc(size);
return (p);
}
void operator delete(void *p){
free(p);
}
|
这段代码可以代替默认的操作符来满足内存分配的请求。出于解释C++的目的，我们也可以直接调用malloc()和free()。
也可以对单个类的new 和 delete操作符重载。这是你能灵活的控制对象的内存分配。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
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
}
|
所有TestClass 对象的内存分配都采用这段代码。更进一步，任何从TestClass 继承的类也都采用这一方式，除非它自己也重载了new 和 delete 操作符。通过重载new 和 delete 操作符的方法，你可以自由地采用不同的分配策略，从不同的内存池中分配不同的类对象。
为单个的类重载new[]和delete[]
必须小心对象数组的分配。你可能希望调用到被你重载过的new 和 delete 操作符，但并不如此。内存的请求被定向到全局的new[]和delete[] 操作符，而这些内存来自于系统堆。
C++将对象数组的内存分配作为一个单独的操作，而不同于单个对象的内存分配。为了改变这种方式，你同样需要重载new[] 和 delete[]操作符。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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[]操作符中的个数参数是数组的大小加上额外的存储对象数目的一些字节。在你的内存分配机制重要考虑的这一点。你应该尽量避免分配对象数组，从而使你的内存分配策略简单。
常见的内存错误及其对策
发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。有时用户怒气冲冲地把你找来，程序却没有发生任何问题，你一走，错误又发作了。 常见的内存错误及其对策如下：
- 内存分配未成功，却使用了它。编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。常用解决办法是，在使用内存之前检查指针是否为
NULL。如果指针p是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存，应该用if(p==NULL)或if(p!=NULL)进行防错处理。 - 内存分配虽然成功，但是尚未初始化就引用它。犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误（例如数组）。内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。所以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦。
- 内存分配成功并且已经初始化，但操作越过了内存的边界。例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在
for循环语句中，循环次数很容易搞错，导致数组操作越界。 - 忘记了释放内存，造成内存泄露。含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。动态内存的申请与释放必须配对，程序中
malloc与free的使用次数一定要相同，否则肯定有错误（new/delete同理）。 - 释放了内存却继续使用它。
有三种情况：
(1). 程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。
(2). 函数的return语句写错了，注意不要返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁。
(3). 使用free或delete释放了内存后，没有将指针设置为NULL。导致产生“野指针”。
那么如何避免产生野指针呢？这里列出了5条规则，平常写程序时多注意一下，养成良好的习惯。
规则1：用
malloc或new申请内存之后，应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存。
规则2：不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。
规则3：避免数组或指针的下标越界，特别要当心发生“多1”或者“少1”操作。
规则4：动态内存的申请与释放必须配对，防止内存泄漏。
规则5：用free或delete释放了内存之后，立即将指针设置为NULL，防止产生“野指针”。
针与数组的对比
C++/C程序中，指针和数组在不少地方可以相互替换着用，让人产生一种错觉，以为两者是等价的。
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。数组名对应着（而不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。
指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。指针远比数组灵活，但也更危险。
下面以字符串为例比较指针与数组的特性。
修改内容
下面示例中，字符数组a的容量是6个字符，其内容为 hello。a的内容可以改变，如a[0]= ‘X’。指针p指向常量字符串“world”（位于静态存储区，内容为world），常量字符串的内容是不可以被修改的。从语法上看，编译器并不觉得语句p[0]= ‘X’有什么不妥，但是该语句企图修改常量字符串的内容而导致运行错误。
|
1
2
3
4
5
6
|
char a[] = “hello”;
a[0] = ‘X’;
cout << a << endl;
char *p = “world”; // 注意p指向常量字符串
p[0] = ‘X’; // 编译器不能发现该错误
cout << p << endl;
|
内容复制与比较
不能对数组名进行直接复制与比较。若想把数组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来比较。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
// 数组…
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)
…
|
计算内存容量
用运算符sizeof可以计算出数组的容量（字节数）。如下示例中，sizeof(a)的值是12（注意别忘了’’）。指针p指向a，但是sizeof(p)的值却是4。这是因为sizeof(p)得到的是一个指针变量的字节数，相当于sizeof(char*)，而不是p所指的内存容量。C++/C语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。
|
1
2
3
4
|
char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12字节
cout<< sizeof(p) << endl; // 4字节
|
注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。如下示例中，不论数组a的容量是多少，sizeof(a)始终等于sizeof(char *)。
|
1
2
3
|
void Func(char a[100]){
cout<< sizeof(a) << endl; // 4字节而不是100字节
}
|
指针参数是如何传递内存的
如果函数的参数是一个指针，不要指望用该指针去申请动态内存。如下示例中，Test函数的语句GetMemory(str, 200)并没有使str获得期望的内存，str依旧是NULL，为什么？
|
1
2
3
4
5
6
7
8
9
10
|
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释放内存。
如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”，见示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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);
}
|
由于“指向指针的指针”这个概念不容易理解，我们可以用函数返回值来传递动态内存。这种方法更加简单，见示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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语句用错了。这里强调不要用return语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消亡，见示例：
|
1
2
3
4
5
6
7
8
9
10
|
char *GetString(void){
char p[] = "hello world";
return p; // 编译器将提出警告
}
void Test4(void){
char *str = NULL;
str = GetString(); // str 的内容是垃圾
cout<< str << endl;
}
|
用调试器逐步跟踪Test4，发现执行str = GetString语句后str不再是NULL指针，但是str的内容不是“hello world”而是垃圾。
如果把上述示例改写成如下示例，会怎么样？
|
1
2
3
4
5
6
7
8
9
10
|
char *GetString2(void){
char *p = "hello world";
return p;
}
void Test5(void){
char *str = NULL;
str = GetString2();
cout<< str << endl;
}
|
函数Test5运行虽然不会出错，但是函数GetString2的设计概念却是错误的。因为GetString2内的“hello world”是常量字符串，位于静态存储区，它在程序生命期内恒定不变。无论什么时候调用GetString2，它返回的始终是同一个“只读”的内存块。
杜绝“野指针”
“野指针”不是NULL指针，是指向“垃圾”内存的指针。人们一般不会错用NULL指针，因为用if语句很容易判断。但是“野指针”是很危险的，if语句对它不起作用。 “野指针”的成因主要有三种：
(1). 指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。例如：
|
1
2
|
char *p = NULL;
char *str = (char *) malloc(100);
|
(2). 指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。
(3). 指针操作超越了变量的作用域范围。这种情况让人防不胜防，示例程序如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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就成了“野指针”。但奇怪的是我运行这个程序时居然没有出错，这可能与编译器有关。
有了malloc/free为什么还要new/delete
可以参考文章 new/malloc区别
malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。
对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。
因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。我们先看一看malloc/free和new/delete如何实现对象的动态内存管理，见示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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则简单得多。
所以我们不要企图用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也一样。
内存耗尽怎么办
如果在申请动态内存时找不到足够大的内存块，malloc和new将返回NULL指针，宣告内存申请失败。通常有三种方式处理“内存耗尽”问题。
(1). 判断指针是否为NULL，如果是则马上用return语句终止本函数。例如：
|
1
2
3
4
5
6
|
void Func(void){
A *a = new A;
if(a == NULL)
return;
…
}
|
(2). 判断指针是否为NULL，如果是则马上用exit(1)终止整个程序的运行。例如：
|
1
2
3
4
5
6
7
8
9
|
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++使用手册。
上述 (1)、(2) 方式使用最普遍。如果一个函数内有多处需要申请动态内存，那么方式 (1) 就显得力不从心（释放内存很麻烦），应该用方式 (2) 来处理。
很多人不忍心用exit(1)，问：“不编写出错处理程序，让操作系统自己解决行不行？”
不行。如果发生“内存耗尽”这样的事情，一般说来应用程序已经无药可救。如果不用exit(1) 把坏程序杀死，它可能会害死操作系统。道理如同：如果不把歹徒击毙，歹徒在老死之前会犯下更多的罪。
有一个很重要的现象要告诉大家。对于32位以上的应用程序而言，无论怎样使用malloc与new，几乎不可能导致“内存耗尽”。对于32位以上的应用程序，“内存耗尽”错误处理程序毫无用处。这下可把Unix和Windows程序员们乐坏了：反正错误处理程序不起作用，我就不写了，省了很多麻烦。
必须强调：不加错误处理将导致程序的质量很差，千万不可因小失大。
|
1
2
3
4
5
6
7
8
9
|
void main(void){
float *p = NULL;
while(TRUE){
p = new float[1000000];
cout << “eat memory” << endl;
if(p==NULL)
exit(1);
}
}
|
malloc/free的使用要点
函数malloc的原型如下：
|
1
|
void * malloc(size_t size);
|
用malloc申请一块长度为length的整数类型的内存，程序如下：
|
1
|
int *p = (int *) malloc(sizeof(int) * length);
|
我们应当把注意力集中在两个要素上：“类型转换”和“sizeof”。
* malloc返回值的类型是void*，所以在调用malloc时要显式地进行类型转换，将void *转换成所需要的指针类型。
* malloc函数本身并不识别要申请的内存是什么类型，它只关心内存的总字节数。我们通常记不住int, float等数据类型的变量的确切字节数。例如int变量在16位系统下是2个字节，在32位下是4个字节；而float变量在16位系统下是4个字节，在32位下也是4个字节。最好用以下程序作一次测试：
|
1
2
3
4
5
6
7
8
|
cout << sizeof(char) << endl;
cout << sizeof(int) << endl;
cout << sizeof(unsigned int) << endl;
cout << sizeof(long) << endl;
cout << sizeof(unsigned long) << endl;
cout << sizeof(float) << endl;
cout << sizeof(double) << endl;
cout << sizeof(void *) << endl;
|
在malloc的“()”中使用sizeof运算符是良好的风格，但要当心有时我们会昏了头，写出 p = malloc(sizeof(p))这样的程序来。
函数free的原型如下：
|
1
|
void free( void * memblock );
|
为什么free函数不象malloc函数那样复杂呢？这是因为指针p的类型以及它所指的内存的容量事先都是知道的，语句free(p)能正确地释放内存。如果p是NULL指针，那么free对p无论操作多少次都不会出问题。如果p不是NULL指针，那么free对p连续操作两次就会导致程序运行错误。
new/delete的使用要点
运算符new使用起来要比函数malloc简单得多，例如：
|
1
2
|
int *p1 = (int *)malloc(sizeof(int) * length);
int *p2 = new int[length];
|
这是因为new内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言，new在创建动态对象的同时完成了初始化工作。如果对象有多个构造函数，那么new的语句也可以有多种形式。例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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创建对象数组，那么只能使用对象的无参数构造函数。例如：
|
1
|
Obj *objects = new Obj[100]; // 创建100个动态对象
|
不能写成：
|
1
|
Obj *objects = new Obj[100](1);// 创建100个动态对象的同时赋初值1
|
在用delete释放对象数组时，留意不要丢了符号‘[]’。例如：
|
1
2
|
delete []objects; // 正确的用法
delete objects; // 错误的用法
|
后者有可能引起程序崩溃和内存泄漏。
函数返回数组要点
下面四个函数都想返回一个数组，只有一个C函数可以成功执行。如果你想从一个函数返回一个数组的话，那么你的数组就得在堆上分配内存，并返回一个指向内存头的指针。A函数返回的是整形，也就是堆上手动申请的内存的第一块，B函数返回的是一个局部变量，变量出了自己的作用域被销毁。
然后是D函数，D函数那就很厉害了，单凭看是看不出来它有什么错误的，想成功运行D函数有几种方式。第一种，主函数里定义整形变量int a，调用D(&a)，这样是可以的，但是不符合题目要求，因为我们要返回数组，这样只返回了第一个元素。第二种，主函数定义整形变量指针int *p = null，调用D(&p)，不好意思，运行时错误。我们要想在函数中改变指针的值，就得想函数传入一个二级指针。第三种，在主函数手动分配内存，int *p = new int；呃，好像跟上面那个是一样的。所以，这个也行不通了。
int A()
{
int *a = new int(3);
return *a;
}
int *B()
{
int a[3] = { 1, 2, 3 };
return a;
}
vector<int> C()
{
vector<int> v(3);
return v;
}
void D(int *ret)
{
int a[3] = { 1, 2, 3 };
ret = a;
}
266
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
