new和malloc的区别及内存管理及char[]与char*区别

Myth丶恋晨 2022-08-07 04:43 12阅读 0赞

**1：new和malloc的区别** 转载地址：http://www.cnblogs.com/fly1988happy/archive/2012/04/26/2470542.html

1. malloc()函数  
1.1 malloc的全称是memory allocation，中文叫动态内存分配。  
原型：extern void \*malloc(unsigned int num\_bytes);  
说明：分配长度为num\_bytes字节的内存块。如果分配成功则返回指向被分配内存的指针，**分配失败返回空指针NULL**。当内存不再使用时，应使用free()函数将内存块释放。

1.2 void \*malloc(int size);  
说明：malloc 向系统申请分配指定size个字节的内存空间，返回类型是 void\* 类型。void\* 表示未确定类型的指针。C,C++规定，void\* 类型可以强制转换为任何其它类型的指针。 　　  
备注：void\* 表示未确定类型的指针，更明确的说是指申请内存空间时还不知道用户是用这段空间来存储什么类型的数据（比如是char还是int或者...）

1.3 free  
void free(void \*FirstByte)： 该函数是将之前用malloc分配的空间还给程序或者是操作系统，也就是释放了这块内存，让它重新得到自由。

1.4注意事项  
1）申请了内存空间后，**必须检查是否分配成功**。  
2）当不需要再使用申请的内存时，**记得释放；释放后应该把指向这块内存的指针指向NULL**，防止程序后面不小心使用了它。  
3）这两个函数应该是配对。如果申请后不释放就是内存泄露；如果无故释放那就是什么也没有做。**释放只能一次，如果释放两次及两次以上会出现错误**（释放空指针例外，释放空指针其实也等于啥也没做，所以释放空指针释放多少次都没有问题）。  
4）虽然malloc()函数的类型是(void \*),任何类型的指针都可以转换成(void \*),但是最好还是在前面进行强制类型转换，因为这样可以躲过一些编译器的检查。

1.5 malloc()到底从哪里得到了内存空间？  
答案是从堆里面获得空间。也就是说函数返回的指针是指向堆里面的一块内存。操作系统中有一个记录空闲内存地址的链表。当操作系统收到程序的申请时，就会遍历该链表，然后就寻找第一个空间大于所申请空间的堆结点，然后就将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。

2. new运算符

2.1 C++中，用new和delete动态创建和释放数组或**单个对象**。

动态创建对象时，**只需指定其数据类型，而不必为该对象命名**，new表达式**返回指向该新创建对象的指针**，我们可以**通过指针来访问此对象**。  
int \*pi=new int;  
这个new表达式在堆区中分配创建了一个整型对象，并返回此对象的地址，并用该地址初始化指针pi 。

2.2 动态创建对象的初始化

动态创建的对象可以用初始化变量的方式初始化。  
int \*pi=new int(100); //指针pi所指向的对象**初始化**为100  
string \*ps=new string(10,’9’);//\*ps 为“9999999999”

**如果不提供显示初始化，**对于类类型，用该类的**默认构造函数初始化**；而**内置类型的对象则无初始化**。  
也可以对动态创建的对象做值初始化：  
int \*pi=new int( );//初始化为0  
int \*pi=new int;//pi 指向一个没有初始化的int  
string \*ps=new string( );//初始化为空字符串 （对于提供了默认构造函数的类类型，没有必要对其对象进行值初始化）

2.3 撤销动态创建的对象

delete表达式释放指针指向的地址空间。  
delete pi ;// 释放单个对象  
delete \[ \]pi;//释放数组  
如果指针指向的不是new分配的内存地址，则使用delete是不合法的。

2.4 在delete之后，重设指针的值

delete p; //执行完该语句后，p变成了不确定的指针，在很多机器上，尽管p值没有明确定义，但仍然存放了它之前所指对象的地址，然后p所指向的内存已经被释放了，所以p不再有效。此时，该指针变成了悬垂指针（悬垂指针指向曾经存放对象的内存，但该对象已经不存在了）。悬垂指针往往导致程序错误，而且很难检测出来。  
**一旦删除了指针所指的对象，立即将指针置为0**，这样就非常清楚的指明指针不再指向任何对象。（零值指针：int \*ip=0;）；0指针可以被多次删除，而非0动态对象的指针只能被删除一次，否则程序会崩溃！

2.5 区分零值指针和NULL指针

零值指针，是值是0的指针，可以是任何一种指针类型，可以是通用变体类型void\*也可以是char\*，int\*等等。  
空指针，其实空指针只是一种编程概念，就如一个容器可能有空和非空两种基本状态，而在非空时可能里面存储了一个数值是0，因此空指针是人为认为的指针不提供任何地址讯息。参考：[http://www.cnblogs.com/fly1988happy/archive/2012/04/16/2452021.html][http_www.cnblogs.com_fly1988happy_archive_2012_04_16_2452021.html]

2.6 **new分配失败时，返回什么？（以前要求返回的是null，现在要求抛出异常，当然可以用int \*p = new(nothrow) int;来表明分配失败直接返回null，而不抛出异常）**

1993年前，c++一直要求在内存分配失败时operator new要**返回0**，现在则是要求operator new**抛出std::bad\_alloc异常**。很多c++程序是在编译器开始支持新规范前写的。c++标准委员会不想放弃那些已有的遵循返回0规范的代码，所以他们提供了另外形式的operator new(以及operator new\[\])以继续提供返回0功能。这些形式被称为“无抛出”，因为他们没用过一个throw，而是**在使用new的入口点采用了nothrow对象**:  
class widget \{ ... \};

widget \*pw1 = new widget;// 分配失败抛出std::bad\_alloc

if (pw1 == 0) ... // 这个检查一定失败

widget \*pw2 = new (nothrow) widget; // 若分配失败返回0

if (pw2 == 0) ... // 这个检查可能会成功

3. malloc和new的区别

3.1 **new 返回指定类型的指针，并且可以自动计算所需要大小。**  
比如： 　　  
1) int \*p; 　　  
p = new int; //返回类型为int\* 类型(整数型指针)，分配大小为 sizeof(int); 　　  
或： 　　  
int\* parr; 　　  
parr = new int \[100\]; //返回类型为 int\* 类型(整数型指针)，分配大小为 sizeof(int) \* 100; 　　  
2) 而 **malloc 则必须要由我们计算字节数，并且在返回后强行转换为实际类型的指针。** 　　  
int\* p; 　　  
p = (int \*) malloc (sizeof(int)\*128);//分配128个（可根据实际需要替换该数值）整型存储单元，并将这128个连续的整型存储单元的首地址存储到指针变量p中  
double \*pd=(double \*) malloc (sizeof(double)\*12);//分配12个double型存储单元，并将首地址存储到指针变量pd中

3.2 **malloc 只管分配内存，并不能对所得的内存进行初始化，**所以**得到的一片新内存中，其值将是随机的**。  
除了分配及最后释放的方法不一样以外，通过malloc或new得到指针，在其它操作上保持一致。

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

1) malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。  
2) 对于**非内部数据类型的对象**而言，光用maloc/free无法满足动态对象的要求。**对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。**由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。  
因此C++语言**需要一个能完成动态内存分配和初始化工作的运算符new**，以及**一个能完成清理与释放内存工作的运算符delete。**注意new/delete不是库函数。  
我们不要企图用malloc/free来完成动态对象的内存管理，应该用new/delete。由于内部数据类型的“对象”没有构造与析构的过程，对它们而言malloc/free和new/delete是等价的。  
3) 既然new/delete的功能完全覆盖了malloc/free，为什么C++不把malloc/free淘汰出局呢？这是因为C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。

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

还有一个区别：

堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由 malloc 函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。

题目：

使用 char\* p = new char\[100\]申请一段内存，然后使用delete p释放，有什么问题？（答案：不会有内存泄露，但不建议用）

分析：C++告诉我们在回收用 new 分配的单个对象的内存空间的时候用 delete，回收用 new\[\] 分配的一组对象的内存空间的时候用 delete\[\]。   
关于 new\[\] 和 delete\[\]，其中又分为两种情况：(1) 为基本数据类型分配和回收空间；(2) 为自定义类型(类类型)分配和回收空间。  
基本类型的对象没有析构函数，所以回收基本类型组成的数组空间用 delete 和 delete\[\] 都是应该可以的；但是对于类对象数组，只能用 delete\[\]。  
 所以一个简单的使用原则就是：new 和 delete、new\[\] 和 delete\[\] 对应使用。

**2：正确的C++内存分区** 转自：http://www.cnblogs.com/madonion/articles/2269195.html

前导：作为一个C++的菜鸟，一直对C++的内存分区比较晕乎，网络上的分配方式各式各样，让人看得云里雾里。网络上有一种分区，将C++内存分为：堆区、栈区、自由存储区、全局/静态存储区和常量存储区。个人认为这是完全错误的内存划分方式，误导我这样的菜鸟。鉴于此，我查找资料，整理出以下的结论。

真正合理的C++的内存划分为栈区、堆区、全局区/静态区、字符串常量和代码区。

这里去掉自由存储区，增加了代码区，理由会在下面讲到。

栈区：由系统进行内存的管理。

说明：主要存放函数的参数以及局部变量。栈区由系统进行内存管理，在函数完成执行，系统自行释放栈区内存，不需要用户管理。整个程序的栈区的大小可以在编译器中由用户自行设定，默认的栈区大小为3M。

全局/静态区：全局、静态数据存放在一起的，初始化的全局变量和静态变量是在一起的。未初始化的全局变量和静态变量是在相邻的空间中。

说明：全局变量和静态全局变量的存储方式是一致的，但是其区别在于，全局变量在整个源代码中都可以使用，而静态全局变量只能在当前文件中有效。比如我们的一个程序有5个文件，那么某个文件中申请了静态全局变量，这个静态全局变量只能在当前文件中使用，其他四个文件均不可以使用。而某个文件中申请了全局变量，那么其他四个文件中都可以使用该全局变量（只需要通过关键字extern申明一下就可以使用了）。事实上static改变了变量的作用范围。

字符串常量区：存放字符串常量，程序结束后，由系统进行释放。比如我们定义char \* p = “Hello World”; 这里的“Hello World”就是在字符串常量中，最终系统会自动释放。

代码区：存放程序体的二进制代码。比如我们写的函数，都是在代码区的。

堆区：由用户手动申请，手动释放。在C中使用malloc，在C++中使用new（当然C++中也可以使用malloc）。

说明：new操作符本质上还是使用了malloc进行内存的申请，因此我将自由存储区和堆区都说成堆区，不过两者还是有很大的差别。

1）malloc是C语言中的函数，而new是C++中的操作符。

2）malloc申请之后返回的类型是VOID\*，而new返回的指针带有类型。

3）malloc只负责内存的分配而不会调用类的构造函数，而new不仅会分配内存，而且会自动调用类的构造函数。

静态 [局部变量][Link 1]有以下特点： 全局静态变量也会初始化为0，即使没有初始化。

该变量在全局数据区分配内存；

静态 [局部变量][Link 1]在程序执行到该对象的声明处时被首次初始化，即以后的 [函数调用][Link 2]不再进行初始化；

静态 [局部变量][Link 1]一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0；

它始终驻留在全局数据区，直到程序运行结束。但其 [作用域][Link 3]为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束；

**3：C++中char\*和char\[\]的区别**  转自：http://blog.sina.com.cn/s/blog\_47fa4cef0100hgnj.html

程序演示：

测试环境Devc++

代码

\#include <iostream>

using namespace std;

main()

char \*c1 = "abc";

char c2\[\] = "abc";

char \*c3 = ( char\* )malloc(3);

c3 = "abc";

printf("%d %d %s\\n",&c1,c1,c1);

printf("%d %d %s\\n",&c2,c2,c2);

printf("%d %d %s\\n",&c3,c3,c3);

getchar();

运行结果

2293628 4199056 abc

2293624 2293624 abc

2293620 4199056 abc

参考资料：

首先要了解编译程序占用的内存的分区形式：

一个由c/C++编译的程序占用的内存分为以下几个部分

1、栈区（stack）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于

数据结构中的栈。

2、堆区（heap）—一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据

结构中的堆是两回事，分配方式倒是类似于链表，呵呵。

3、全局区（静态区）（static）—全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态

变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统

释放。

4、文字常量区—常量字符串就是放在这里的。程序结束后由系统释放。

5、程序代码区

//main.cpp

int a=0;//全局初始化区

char \*p1; //全局未初始化区

main()

int b;栈

char s\[\]="abc"; //栈

char \*p2;//栈

char \*p3="123456"; //123456\\0在常量区，p3在栈上。

static int c=0； //全局（静态）初始化区

p1 = (char\*)malloc(10);

p2 = (char\*)malloc(20); //分配得来得10和20字节的区域就在堆区。

strcpy(p1,"123456"); //123456\\0放在常量区，编译器可能会将它与p3所向"123456"优化成一个

//地方。

二、堆和栈的理论知识

2.1申请方式

stack:由系统自动分配。例如，声明在函数中一个局部变量int b;系统自动在栈中为b开辟空间

heap:需要程序员自己申请，并指明大小，在c中malloc函数

如p1=(char\*)malloc(10);

在C++中用new运算符

如p2=(char\*)malloc(10);

但是注意p1、p2本身是在栈中的。

2.2

申请后系统的响应

栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。

堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，

会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将

该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大

小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正

好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

2.3申请大小的限制

栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地

址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译

时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地

址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的

虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

2.4申请效率的比较：

栈:由系统自动分配，速度较快。但程序员是无法控制的。

堆:是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.

另外，在WINDOWS下，最好的方式是用Virtual Alloc分配内存，他不是在堆，也不是在栈,而是直接在进

程的地址空间中保留一块内存，虽然用起来最不方便。但是速度快，也最灵活。

2.5堆和栈中的存储内容

栈：在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的

地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变

量。注意静态变量是不入栈的。

当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主

函数中的下一条指令，程序由该点继续运行。

堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。

2.6存取效率的比较

char s1\[\]="aaaaaaaaaaaaaaa";

char \*s2="bbbbbbbbbbbbbbbbb";

aaaaaaaaaaa是在运行时刻赋值的；

而bbbbbbbbbbb是在编译时就确定的；

但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。

比如：

\#include

voidmain()

char a=1;

char c\[\]="1234567890";

char \*p="1234567890";

a = c\[1\];

a = p\[1\];

return;

对应的汇编代码

10:a=c\[1\];

004010678A4DF1movcl,byteptr\[ebp-0Fh\]

0040106A884DFCmovbyteptr\[ebp-4\],cl

11:a=p\[1\];

0040106D8B55ECmovedx,dwordptr\[ebp-14h\]

004010708A4201moval,byteptr\[edx+1\]

004010738845FCmovbyteptr\[ebp-4\],al

第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据

edx读取字符，显然慢了。

2.7小结：

堆和栈的区别可以用如下的比喻来看出：

使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会

切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。

使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

自我总结：

char \*c1 = "abc";实际上先是在文字常量区分配了一块内存放"abc",然后在栈上分配一地址给c1并指向

这块地址，然后改变常量"abc"自然会崩溃然而char c2\[\] = "abc",实际上abc分配内存的地方和上者并不一样，

可以从4199056 2293624 看出，完全是两块地方，推断4199056处于常量区，而2293624处于栈区，

2293628 2293624 2293620 这段输出看出三个指针分配的区域为栈区，而且是从高地址到低地址，

2293620 4199056 abc 看出编译器将c3优化指向常量区的"abc"

继续思考：

代码：

\#include <iostream>

using namespace std;

main()

char \*c1 = "abc";

char c2\[\] = "abc";

char \*c3 = ( char\* )malloc(3);

//  \*c3 = "abc" //error

strcpy(c3,"abc");

c3\[0\] = 'g';

printf("%d %d %s\\n",&c1,c1,c1);

printf("%d %d %s\\n",&c2,c2,c2);

printf("%d %d %s\\n",&c3,c3,c3);

getchar();

输出：

2293628 4199056 abc

2293624 2293624 abc

2293620 4012976 gbc

写成注释那样，后面改动就会崩溃

可见strcpy(c3,"abc");abc是另一块地方分配的，而且可以改变，和上面的参考文档说法有些不一定.\*c3 = "abc";

这句话本来就有问题，编译都通不过

c3是指针变量，所指的内容是char型.而你这句话是想让它所指的内容变成字符串，显然是不对的 c3 = "abc";

这样就没问题了

但此时，c3存储的就是的字符串常量的地址了，所以不能再给c3所指的内容赋值了：c3\[0\] = 'g';是非法的

举个例子：

char buf1\[128\];

char\* buf2 = new char\[128\];

buf2 = buf1; //正常编译通过

buf1 = buf2; //编译错误，不能char\[\] convert to char\*

原因buf1为指针常量，指向的地址不能改变，buf2为指针变量，指向的地址可以改变

可以通过字符拷贝函数实现内容复制：

strcpy(buf1,buf2); buf1目的，buf2源，  buf2的内容给buf1

首先看指针:

char \*p = “helloworld”;

在这里p是一个变量,其类型为指针类型,并且指向一个字符串,字符串内容为”helloworld”,如果要访问p\[2\]的话,就需要先从p中取出地址,该地址为”helloworld”的首地址,然后再加上偏移量2,就得到了’l’这个字符,所以其访问的方式为先从p中取出地址,然后再将该地址加上偏移量,得到一个地址,最后从这个地址中取出值来.

其分为三步:

取p的值,该值即为字符串的首地址.

该地址加上偏移量,得到所要取的字符的地址.

从这个地址中取得值.

此处p是一个变量,它自己是存放在一个地址中的,而它的内容则是”helloworld”这个字符串的地址. p与字符串是分开的.

同时,该指针的值是动态确定的,必须在运行的时候才能确定其值,并通过该值访问到字符串.

而如果是数组的话,则为

char p\[20\] = “helloworld”; p为helloworld在栈中存放的地址。helloworld存放在栈中值。

在这里p为一个字符串的标识,其类型是一个字符数组的类型,且该数组有20个char类型的大小.此时如果要访问p\[2\]的话,就直接使用该字符数组的首地址加上2个char类型的大小的长度就得到了要访问的字符的地址,最后再从这个地址中取出值来.而且此时p的地址为该字符数组的首地址,其内容为’h’.一个字符类型.

所以在这个地方数组与指针是不相同的,因为此时数组取值的第一步并不是从p中读取地址来再加上偏移量的.此时的p这个地址的值就为’h’这个字符,其类型为字符型而不是一个指针类型.此时p的地址与p\[0\]的地址是相同的.

同时,每个符号的地址在编译时就确定了,所以这里p的地址就已经确定了,如果需要访问p\[2\],则直接使用该地址加上2这个偏移量就可以取到这个值了.它不需要指令再取得这个首地址.而第一种情况下,还需要指令取得指针中的值,并通过这个值来访问字符串.

一个直观的看法就是前一种是两个不同的, 而后一种则是在同一个里面.

另外还有一个不同之处在于第一个情况下 p 指向的是一个常量区, 是不能改变的, 即不能够对p\[i\]赋值, 而第二种情况下, p是一个字符数组, 其是可以改变的. 可以对p\[i\]赋值的.

[http_www.cnblogs.com_fly1988happy_archive_2012_04_16_2452021.html]: http://www.cnblogs.com/fly1988happy/archive/2012/04/16/2452021.html
[Link 1]: http://baike.baidu.com/view/552847.htm
[Link 2]: http://baike.baidu.com/view/2369016.htm
[Link 3]: http://baike.baidu.com/view/657404.htm