globalalloc、malloc和new的区别

合集下载

calloc函数和malloc

calloc函数和malloccalloc和malloc都是C语言中分配内存的函数，它们有一些共同点和不同点。

共同点：1. 两个函数都是用来分配内存的，返回一个void *类型的指针，可以用来操作新分配的内存。

2. 分配的内存长度由用户指定，可以是任何整数。

3. 如果分配的内存不被使用了，可以使用free函数将其释放。

1. 分配的方式不同。

malloc函数只分配内存空间，但不初始化分配的内存区域。

而calloc函数分配的内存空间会被初始化为0。

2. 分配的参数不同。

malloc只接受一个参数来指定需要分配的空间大小，而calloc 函数需要两个参数，第一个参数是需要分配的连续内存区域个数，第二个参数是每个内存区域的大小。

3. 分配的效率不同。

calloc相比malloc可能会更慢一些，因为它需要初始化分配的内存区域，而malloc不需要这样做。

下面分别介绍一下这两个函数的用法：1. mallocmalloc用于分配内存，原型如下：void *malloc(size_t size);其中size_t是无符号整型变量，用来表示要分配的内存大小。

使用示例：```int *p = (int *)malloc(sizeof(int));if(p == NULL){printf("分配内存失败。

\n");}else{*p = 123;printf("*p = %d\n", *p);free(p);}```这段代码先分配了一个int类型的变量所需的内存空间，然后将分配的地址赋值给指针p。

如果分配失败，则p将被赋值为NULL；如果分配成功，则可以通过指针p来操作新分配的内存。

最后，使用free函数释放分配的内存。

其中num是需要分配的连续内存区域个数，size是每个内存区域的大小。

总结：calloc和malloc在分配内存时具有不同的作用。

calloc分配的空间会被初始化为0，而malloc分配的空间不做初始化。

new与delete区别

new与malloc1.malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。

它们都可用于申请动态内存和释放内存2.对于非内部数据类型的对象(由enum，union，class、struct等关键字修饰的变量, 基本数据类型如int,char,double等都是内部数据类型,)而言，光用maloc/free无法满足动态对象的要求。

对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。

由malloc/free 是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。

3.因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以一个能完成清理与释放内存工作的运算符delete。

注意new/delete不是库函数。

4.C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。

5.new可以认为是malloc加构造函数的执行。

new出来的指针是直接带类型信息的。

而malloc 返回的都是void*指针。

new delete在实现上其实调用了malloc,free函数6.new建立的对象你可以把它当成一个普通的对象,用成员函数访问,不要直接访问它的地址空间;malloc分配的是一块内存区域,就用指针访问好了,而且还可以在里面移动指针.7.new 建立的是一个对象；malloc分配的是一块内存.相同点：都可用于申请动态内存和释放内存联系；既然new/delete的功能完全覆盖了malloc /free，为什么C++还保留malloc/free 呢？因为C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。

如果用free释放“new创建的动态对象”，那么该对象因无法执行析构函数而可能导致程序出错。

如果用delete释放“malloc申请的动态内存”，理论上讲程序不会出错，但是该程序的可读性很差。

明晰C++内存分配的五种方法的区别

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

栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。

里面的变量通常是局部变量、函数参数等。

堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。

如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。

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

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

常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多，在《const的思考》一文中，我给出了6种方法）明确区分堆与栈在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。

首先，我们举一个例子：void f() { int* p=new int[5]; }这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。

在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：00401028 push 14h0040102A call operator new (00401060)0040102F add esp,400401032 mov dword ptr [ebp-8],eax00401035 mov eax,dword ptr [ebp-8]00401038 mov dword ptr [ebp-4],eax这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。

用C的malloc和C++的new开辟空间的区别

1. new 不但分配对象空间, 还会在分配后调用对象的构造函数,需要手动使用delete来调用析构函数释放空间，而malloc 只是分配, 不构造:class A{public:A(): m_value(0){}//构造函数public:int m_value;};struct B{Int a;};A *pb1 = new A;Struct B *pb2 = (B *)malloc(sizeof(B));pb1 因为被new 调用了构造函数, 所以pb1->m_value == 0, pb2 的构造函数没有被调用, 所以pb2->m_value 的值不确定(即未初始化).2. new 分配时要指定类型, 是类型安全的; 而malloc 返回的是void *, 类型不安全; 类型不安全的东西在C++ 里是不被提倡的!3.引用只是别名不能作为指针来直接使用，&p=new int;是错误的，但是可以定义如下：int *p=new int;int &rp=p;这样的是rp为指针变量p的别名，*rp就是指针变量p所指向的内容。

4.指针可以指向不同的地址，但是引用不能，它只能指向一个，如：int *p=new int;//引用必须要为对象int a,b;p=&a;p=&b;可以使用。

Int a,b;Int &rt=a;&rt=b;会出现错误。

指针不用初始化，但是引用必须初始化。

int &ra;&ra=a;会报错。

引用的一定是对象，否则会出错如：int *p;int &rp=p;会出错。

5.引用只能在块中使用，不能出块。

如：{int a;int &ra=a;ra=9;}ra=10;//出错，因为出了定义引用的块，他只能在相应的｛｝中使用。

6.const A *const(cost A *const one)中的各个const的意义如下：(1):表示返回的指针值的对象是不能修改的(2):表示返回的指针是不可以修改的(3):表示指针变量one所指的内容是不可以修改的(4):表示指针变量one是不可以修改的。

malloc和colloc区别

三个函数的声明分别是:void* realloc(void* ptr, unsigned newsize);void* malloc(unsigned size);void* calloc(size_t nelem, size_t elsize);都在stdlib.h函数库内它们的返回值都是请求系统分配的地址,如果请求失败就返回NULLmalloc用于申请一段新的地址,参数size为需要内存空间的长度,如:char* p;p=(char*)malloc(20);calloc与malloc相似,参数elsize 为申请地址的单位元素长度,nelem为元素个数,如:char* p;p=(char*)calloc(20, sizeof(char));这个例子与上一个效果相同realloc是给一个已经分配了地址的指针重新分配空间,参数ptr为原有的空间地址,newsize是重新申请的地址长度< type="text/javascript"> < src="/pagead/show_ads.js" type="text/javascript">< type="text/javascript"> < src="/pagead/show_ads.js" type="text/javascript">如:char* p;p=(char*)malloc(sizeof(char)*20);p=(char*)realloc(p,sizeof(char)*40);注意，这里的空间长度都是以字节为单位。

C语言的标准内存分配函数：malloc，calloc，realloc等。

malloc与calloc的区别为1块与n块的区别：malloc调用形式为(类型*)malloc(size)：在内存的动态存储区中分配一块长度为“size”字节的连续区域，返回该区域的首地址。

globalalloc、malloc和new的区别

GlobalAlloc是为了与Win16兼容才保留的，在Win32下不要使用。

全局内存对象使用GlobalAlloc函数分配,在Windows 3.X 的时代，分配的内存可以有两种，全局的和局部的，例如GlobalAlloc和LocalAlloc。

但在Win32的时代这些函数已经被废弃了，现在的内存只有一种就是虚存。

在Win32中所有的进程所使用的内存区域是相互隔离的，每个进程都拥有自己的地址空间。

而且系统使用了页面交换功能，就是利用磁盘空间来模拟RAM，在RAM中数据不使用时将会被交换到磁盘，在需要时将会被重新装入RAM。

两者都是在堆上分配内存区。

malloc()是C运行库中的动态内存分配函数，WINDOWS程序基本不使用了，因为它比WINDOWS内存分配函数少了一些特性，如，整理内存。

GlobalAlloc()是16位WINDOWS程序使用的API，返回一个内存句柄，在实际需要使用时，用GlobalLock()来实际得到内存区。

但，32位WINDOWS系统中，应使用新的内存分配函数HeapAlloc()以得到更好的支持，GlobalAlloc()还可以用，主要是为了兼容。

HeapAlloc apply memory from kernel32.dllGlobalAlloc obsolete malloc apply memory form C runtime memory ,and C r untime applys from kernel32.dll new a wrapper of malloc but it is NOT a must for new to implementbased on malloc.CoMemAlloc apply memory from kernel32.dllall are heap memory.recommend HeapAlloc for big block memory allocationrecommend stack memory space.recommend HeapAlloc for big block memory allocationrecommend stack memory space.malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。

【Z】C面试题413

1、进程和线程的区别进程是系统进行资源分配和调度的单位。

线程是CPU调度和分派的单位，一个进程可以有多个线程，这些线程共享这个进程的资源。

2、成员变量和成员函数前加static的作用它们被称为常成员变量和常成员函数，又称为类成员变量和类成员函数。

分别用来反映类的状态。

比如类成员变量可以用来统计类实例的数量，类成员函数负责这种统计的动作。

3、malloc和new的区别new是C++的关键字。

malloc在分配内存时必须按给出的字节分配，new可以按照对象的大小自动分配，并且能调用构造函数。

可以说new是对象的对象，而malloc不是。

本质上new分配内存时，还会在实际内存块的前后加上附加信息，所以new所使用的内存大小比malloc多。

4、堆和栈的区别栈：由编译器自动分配、释放。

在函数体中定义的变量通常在栈上。

堆：一般由程序员分配释放。

用new、malloc等分配内存函数分配得到的就是在堆上。

栈是机器系统提供的数据结构，而堆则是C/C++函数库提供的。

栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活。

而栈是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。

栈是系统数据结构，对于进程/线程是唯一的。

堆是函数库内部数据结构，不一定唯一。

不同堆分配的内存无法互相制作。

栈空间分静态分配和动态分配两种。

静态分配是编译器完成的，比如自动变量(auto)的分配。

动态分配由alloca函数完成。

栈的动态分配无需释放(是自动的)，也就没有释放函数。

为可移植的程序起见，栈的动态分配制作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/释放内存匹配是良好程序的基本要素。

5、不调用C++/C的字符串库函数，请编写函数 strcpy1. C#中 property 与 attribute的区别，他们各有什么用处，这种机制的好处在哪里？2. 讲一讲你理解的web service,在dot net framework中，怎么很好的结合xml?（讲概念就行了）3. C#, Java 和 c++的特点，有什么相同的地方，不同的地方，C#分别从c++和java中吸取了他们那些优点？4. C#可否对内存进行直接的制作？(这可是个难点哦？要注意！）5. 用Visual C++6.0编写的代码(unmanaged code)，如何在CLR下和其他dot net component结合？6. 以前作过的一些项目？推荐一下自己的编程经验。

malloc、calloc、new的区别

malloc、calloc、new的区别这⼏个都是动态申请空间⽤到的关键字。

malloc定义：calloc定义：new定义：、FutureNow这个⼈整理的挺好的。

malloc和calloc的区别：calloc在动态分配完内存后，⾃动初始化该内存空间为零，⽽不做初始化，分配到的空间中的数据是随机数据。

其中malloc的简介如下：原型：extern void* malloc(unsigned int size)； [1]功能：动态分配内存；注意：size仅仅为申请内存字节⼤⼩，与申请内存块中存储的数据类型⽆关，故编程时建议通过以下⽅式给出，"长度 * sizeof(数据类型)"； [2]calloc的⽤法：void *calloc(size_t nmenb, size_t size);calloc()函数为nmemb个元素的数组分配内存空间，其中，每个元素的长度都是size个字节。

如果要求的空间⽆效，那么此函数返回。

在分配了内存之后，calloc()函数会通过将所有位设置为0的⽅式进⾏初始化。

⽐如，调⽤calloc()函数为n个整数的数组分配存储空间，且保证所有整数初始化为0：pi = calloc(n, sizeof(int));因为calloc()函数会清空分配的内存，⽽malloc()函数不会，所以可以调⽤以“1”作为第⼀个实参的calloc()函数，为任何类型的数据项分配空间。

⽐如：struct point{ int x, y;} *pi;pi = calloc(1, sizeof(struct point));在执⾏此语句后，pi将指向⼀个结构体，且此的成员x和y都会被设为0。

⼀般使⽤后要使⽤ (起始地址的指针) 对内存进⾏释放，不然内存申请过多会影响计算机的性能，以⾄于得重启电脑。

如果使⽤过后不清零，还可以使⽤该指针对该块内存进⾏访问。

头⽂件：或.h [1]以上两个进⾏动态分配的空间，⽤完了之后需要⼈为的进⾏动态的释放。

new和malloc的区别

new和malloc的区别⼀、new是操作符，⽽malloc是函数void* malloc(size_t);void free(void*);void *operator new (size_t);void operator delete (void *);void *operator new[] (size_t);void operator delete[] (void *);⼆、new在调⽤的时候先分配内存，在调⽤构造函数，释放的时候调⽤析构函数。

#include <iostream>using namespace std;class Player{public:Player(){cout << "call Player::ctor\n";}~Player(){cout << "call Player::dtor\n";}void Log(){cout << "i am player\n";}};int main(){cout << "Initiate by new\n";Player* p1 = new Player();p1->Log();delete p1;cout << "Initiate by malloc\n";Player* p2 = (Player*)malloc(sizeof(Player));p2->Log();free(p2);}输出结果为：Initiate by newcall Player::ctori am playercall Player::dtorInitiate by malloci am player三、new是类型安全的，malloc返回void*四、new可以被重载五、new分配内存更直接和安全六、malloc 可以被realloc#include <iostream>using namespace std;int main(){char* str = (char*)malloc(sizeof(char*) * 6);strcpy(str, "hello");cout << str << endl;str = (char*)realloc(str, sizeof(char*) * 12);strcat(str, ",world");cout << str << endl;free(str);}输出结果为：hellohello,world七、new发⽣错误抛出异常，malloc返回null⼋、malloc可以分配任意字节，new 只能分配实例所占内存的整数倍数⼤⼩。

C++内存分配秘籍—new,malloc,GlobalAlloc详解

一、关于内存1、内存分配方式内存分配方式有三种：（1）从静态存储区域分配。

内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。

例如全局变量，static变量。

（2）在栈上创建。

在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。

栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

（3）从堆上分配，亦称动态内存分配。

程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。

动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

2.内存使用错误发生内存错误是件非常麻烦的事情。

编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。

而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。

有时用户怒气冲冲地把你找来，程序却没有发生任何问题，你一走，错误又发作了。

常见的内存错误及其对策如下：* 内存分配未成功，却使用了它。

编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。

常用解决办法是，在使用内存之前检查指针是否为NULL。

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

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

犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误（例如数组）。

内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。

所以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦。

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

例如在使用数组时经常发生下标“多1”或者“少1”的操作。

特别是在for循环语句中，循环次数很容易搞错，导致数组操作越界。

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

含有这种错误的函数每被调用一次就丢失一块内存。

new 和 malloc的实现原理

new 和 malloc的实现原理
new 和 malloc 都是用于在动态内存上分配空间的函数，但是
它们的实现原理略有不同。

1. new 的实现原理：
- new 是一个运算符，用于在 C++ 中分配动态内存。

- new 首先调用 operator new 函数来分配一块足够大小的内存。

- 然后调用对象的构造函数，初始化这块内存，并返回指向
该对象的指针。

2. malloc 的实现原理：
- malloc 是 C 语言中的库函数，用于在内存堆上分配内存。

- malloc 首先检查要申请的内存大小，计算所需要的总空间
大小。

- 在堆上找到合适大小的空闲空间，进行分配。

- 返回指向所分配内存的指针。

需要注意的是，new 和 malloc 在内存分配的过程中还有以下
区别：
- new 会自动调用对象的构造函数进行初始化，而 malloc 不会。

- new 会根据对象的类型进行内存分配和释放，而 malloc 只关
心大小。

- new 返回的指针是类型安全的，而 malloc 返回的是 void 指针，需要进行类型转换。

在 C++ 中，建议使用 new 和 delete 运算符，而不是 malloc 和free 函数，以确保对象的正确初始化和析构。

globalalloc函数

globalalloc函数
GlobalAlloc函数是Windows操作系统中的一个API函数，用于在进程的堆内存中分配指定大小的内存块。

这个函数可以用来为应用程序分配一块全局内存，以便在程序运行过程中存储数据或进行其他操作。

使用GlobalAlloc函数可以方便地在堆内存中动态分配内存空间，而不需要在编译时确定内存大小。

这样就可以根据实际需要动态地分配内存，从而提高程序的灵活性和效率。

在使用GlobalAlloc函数时，需要指定要分配的内存块的大小和分配方式。

分配方式包括GMEM_FIXED、GMEM_MOVEABLE、GMEM_ZEROINIT等。

分配的内存块会返回一个内存块句柄，通过这个句柄可以访问和操作分配的内存块。

在使用完分配的内存块后，需要使用GlobalFree函数来释放这块内存，防止内存泄漏。

释放内存后，相应的内存句柄也会失效。

GlobalAlloc函数在Windows操作系统中被广泛应用，在很多程序中都可以看到它的身影。

通过GlobalAlloc函数，程序可以灵活地管理内存，提高内存的利用率和效率。

总的来说，GlobalAlloc函数是一个非常方便实用的函数，可以帮助程序动态分配内存，提高程序的灵活性和效率。

合理使用GlobalAlloc函数，可以有效避免内存泄漏和内存溢出等问题，使程
序更加稳定和高效。

malloc与new函数详解

存和释放内存。对于非内部数据类型的对象而言，光用malloc/free 无法满足动态对象的要求。
对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于
malloc/free 是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析
构函数的任务强加于malloc/free。因此C++语言需要一个能完成动态内存分配和初始化工作
hp = ( struct hostent* ) malloc ( N * sizeof( sturct hostent ) );
if ( !hp ) //建议要加上这个内存分配成功与否的检测
{
// 添加内存分配失败时的处理方法
}
除了分配及最后释放的方法不一样以外，通过malloc或new得到指针，在其它操作上保持一致。
对其做一个特例补充
char *ptr;
if ((ptr = (char *)malloc(0)) == NULL)
puts("Got a null pointer");
else
puts("Got a valid pointer");
的运算符new，以及一个能完成清理与释放内存工作的运算符delete。注意new/delete 不是
库函数。
new delete, free malloc
首先应该知道malloc 和free是匹配的；new和delete是匹配的，他们不可以混淆。
malloc和new都申请空间，但是new是强类型的分配，会调用对象的构造函数初始化对象，而malloc仅分配内存空间但是不初始化。
而 malloc 则必须由我们计算要字节数，并且在返回后强行转换为实际类型的指针。

malloc和new的用法

malloc和new的用法在C和C++编程中，动态内存分配是一种非常重要的技术。

由于程序在运行时可能需要动态地创建变量和数据结构，需要使用动态内存分配技术来满足这些需求。

在C语言中，我们使用malloc函数来动态分配内存；在C++语言中，我们使用new运算符来实现动态内存分配。

1. malloc函数malloc函数的原型如下：void *malloc(size_t size);其中，size_t是一个无符号整数类型，用来表示需要分配的内存空间的大小。

malloc函数返回一个void指针类型，它指向分配的内存空间的起始地址。

如果分配失败，malloc函数返回NULL。

使用malloc函数动态分配内存的步骤如下：(1) 通过调用malloc函数分配内存空间。

(2) 对内存空间进行初始化。

(3) 使用分配的内存空间。

(4) 使用完毕后，需要使用free函数释放内存空间。

2. new运算符new运算符是C++中用于动态分配内存的操作符，它的语法如下：new 类型名 [初始化列表]其中，类型名表示需要分配的内存空间的类型，初始化列表是可选的，用来对分配的内存空间进行初始化。

new运算符返回一个指向类型名所表示的类型的指针。

使用new运算符动态分配内存的步骤如下：(1) 通过调用new运算符分配内存空间。

(2) 对内存空间进行初始化。

(3) 使用分配的内存空间。

(4) 使用完毕后，需要使用delete运算符释放内存空间。

3. malloc和new的区别(1) malloc函数是C语言中的函数，new运算符是C++语言中的运算符。

(2) malloc函数分配的内存空间必须使用free函数释放，而new运算符分配的内存空间必须使用delete运算符释放。

(3) malloc函数分配的内存空间不会被初始化，而new运算符分配的内存空间可以使用初始化列表进行初始化。

(4) new运算符可以自动计算需要分配的内存空间的大小，而malloc函数需要手动指定需要分配的内存空间的大小。

内存分配方式,堆区,栈区,new、delete、malloc、free

1.内存分配方式内存分配方式有三种：[1]从静态存储区域分配。

内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。

例如全局变量，static变量。

[2]在栈上创建。

在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。

栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

[3]从堆上分配，亦称动态内存分配。

程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。

动态内存的生存期由程序员决定，使用非常灵活，但如果在堆上分配了空间，就有责任回收它，否则运行的程序会出现内存泄漏，频繁地分配和释放不同大小的堆空间将会产生堆内碎块。

2.程序的内存空间一个程序将操作系统分配给其运行的内存块分为4个区域，如下图所示。

,1、栈区（stack）由编译器自动分配释放，存放为运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

其操作方式类似于数据结构中的栈。

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

分配方式类似于链表。

3、全局区（静态区）（static）存放全局变量、静态数据、常量。

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

程序结束后由系统释放。

5、程序代码区存放函数体（类成员函数和全局函数）的二进制代码。

下面给出例子程序，3．堆与栈的比较3.1申请方式stack: 由系统自动分配。

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

heap: 需要程序员自己申请，并指明大小，在C中malloc函数，C++中是new运算符。

如p1 = (char *)malloc(10); p1 = new char[10];如p2 = (char *)malloc(10); p2 = new char[20];但是注意p1、p2本身是在栈中的。

new和malloc的区别深入解析

new和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 freevoid free(void *FirstByte)：该函数是将之前⽤malloc分配的空间还给程序或者是操作系统，也就是释放了这块内存，让它重新得到⾃由。

1.4注意事项申请了内存空间后，必须检查是否分配成功。

当不需要再使⽤申请的内存时，记得释放；释放后应该把指向这块内存的指针指向NULL，防⽌程序后⾯不⼩⼼使⽤了它。

这两个函数应该是配对。

如果申请后不释放就是内存泄露；如果⽆故释放那就是什么也没有做。

释放只能⼀次，如果释放两次及两次以上会出现错误（释放空指针例外，释放空指针其实也等于啥也没做，所以释放空指针释放多少次都没有问题）。

虽然malloc()函数的类型是(void *),任何类型的指针都可以转换成(void *),但是最好还是在前⾯进⾏强制类型转换，因为这样可以躲过⼀些编译器的检查。

1.5 malloc()到底从哪⾥得到了内存空间？答案是从堆⾥⾯获得空间。

也就是说函数返回的指针是指向堆⾥⾯的⼀块内存。

操作系统中有⼀个记录空闲内存地址的链表。

C++中的new VS C语言中的malloc

动作不同：在C++中，new一个对象时，程序完成对象的空间的分配的同时，构造函数也被调用，类似，delete一个对象时，对象的空间被释放的同时析构函数也被调用。

在C中，malloc和free 则没有构造函数和析构函数被调用这个动作。

当然，在没有特定的构造函数或析构函数时，C++也没有这个动作。

关于重载：在C++中，对于任何非数组的空间分配，我们可以通过定义函数名相同但参数不同的构造函数完成对构造函数的重载，而对于数组的空间分配，就只能使用默认构造函数了，若你试图去开辟一个没有默认构造函数的数组，Compiler会出错。

在C中，自然是没有重载这个事情了。

返回值不同：在C中，malloc 返回一个void *指针，需要你强制指针类型转换在C++中，你直接new一个就好。

注意，对于基本类型，这个差别是二者唯一的差别，当然不建议在C++中使用malloc+强制类型转换创建基本数据类型或者对象。

定义不同：new是操作符malloc是函数异常处理方式不同：new抛出异常malloc返回NULL 分配空间单位不同： ...by chriszeng87 2011-09-22 回复(0)相关讨论转：C++学习重点分析一、#include “filename.h”和#include 的区别#include “filename.h”是指编译器将从当前工作目录上开始查找此文件#include 是指编译器将从标准库目录中开始查找此文件二、头文件的作用加强安全检测通过头文件可能方便地调用库功能，而不必关心其实现方式三、* , &修饰符的位置对于*和&修饰符，为了避免误解，最好将修饰符紧靠变量 ...by SpringArt 2007-02-26 回复(0)我来学C++<二>我的第一个C++类#include <iostream.h>//导入头文件class Point{//定义类/* 类的定义可以用class 和struct来定义struct 定义的类的成员函数和成员变量默认为public class 定义的类的成员函数和成员变量默认为pritive */ public: int x; int y; Point(){//构造函 ...by zhaojuan8 2009-03-17 回复(2)从main.c开始走进Ruby－登上调试 ...我想更深入的了解Ruby内部的实现，出发点或许过于天真，我想了解下这门语言的实现，从中或许可以学习到某些思路，比如：如果我们要设计另外一种动态语言该如何去下手，如何将其他语言的特性融合进Ruby或者我们要设计的语言，特定领域的特定语言该如何设计（不要一门又广又全的语言，但又不是DSL）。

C语言中的malloc和C++中new的区别

n ew和malloc的区别1、new 是c++中的操作符，malloc是c 中的一个函数2、new 不止是分配内存，而且会调用类的构造函数，同理delete会调用类的析构函数，而malloc则只分配内存，不会进行初始化类成员的工作，同样free也不会调用析构函数3、内存泄漏对于malloc或者new都可以检查出来的，区别在于new可以指明是那个文件的那一行，而malloc没有这些信息。

4、new 和malloc效率比较new 有三个字母, malloc有六个字母new可以认为是malloc加构造函数的执行。

new出来的指针是直接带类型信息的。

而malloc返回的都是void指针。

一：new delete 是运算符，malloc,free是函数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){ cou t << “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模拟了析构函数的功能。

calloc函数和malloc

calloc函数和malloc
在C语言中，动态内存分配对于程序员来说是非常重要的。

malloc和calloc是两个常用的动态内存分配函数。

malloc函数用于在内存中分配一块指定大小的连续空间，并返回分配的内存的地址，以便我们可以在程序中使用它。

例如，以下代码分配了一块大小为10个整数的内存：
int *p = (int*) malloc(10 * sizeof(int));
calloc函数也用于在内存中分配一块指定大小的连续空间，但是它有一个额外的参数：初始化为0。

它接受两个参数：所需的元素数和元素大小。

例如，以下代码分配了一块大小为10个整数的内存并将它们初始化为0：
int *p = (int*) calloc(10, sizeof(int));
因此，calloc和malloc在内存分配方面非常相似，但是它们的行为略有不同。

最重要的区别是：calloc在分配内存时将其设置为0。

这是malloc无法保证的。

另一个区别是：calloc需要更多的时间来执行，因为它不仅分配内存，而且还必须将所有字节设置为0。

在大多数情况下，性能差异不会很大，但是如果您需要分配大量内存，这可能会成为一个问题。

在实践中，选择calloc或malloc通常取决于您的程序的具体需求。

如果您需要分配一些内存，但不需要将其设置为0，则应使用malloc。

如果您需要分配一些内存，并且要将其设置为0，则应使用
calloc。

new和malloc的区别

new和malloc的区别0. 属性new/delete是C++关键字，需要编译器⽀持。

malloc/free是库函数，需要头⽂件⽀持。

1. 参数使⽤new操作符申请内存分配时⽆须指定内存块的⼤⼩，编译器会根据类型信息⾃⾏计算。

⽽malloc则需要显式地指出所需内存的尺⼨。

2. 返回类型new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，⽆须进⾏类型转换，故new是符合类型安全性的操作符。

⽽malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。

3. 分配失败new内存分配失败时，会抛出bac_alloc异常。

malloc分配内存失败时返回NULL。

4. ⾃定义类型new会先调⽤operator new函数，申请⾜够的内存（通常底层使⽤malloc实现）。

然后调⽤类型的构造函数，初始化成员变量，最后返回⾃定义类型指针。

delete先调⽤析构函数，然后调⽤operator delete函数释放内存（通常底层使⽤free实现）。

malloc/free是库函数，只能动态的申请和释放内存，⽆法强制要求其做⾃定义类型对象构造和析构⼯作。

5. 重载C++允许重载new/delete操作符，特别的，布局new的就不需要为对象分配内存，⽽是指定了⼀个地址作为内存起始区域，new在这段内存上为对象调⽤构造函数完成初始化⼯作，并返回此地址。

⽽malloc不允许重载。

6. 内存区域new操作符从⾃由存储区（free store）上为对象动态分配内存空间，⽽malloc函数从堆上动态分配内存。

⾃由存储区是C++基于new操作符的⼀个抽象概念，凡是通过new操作符进⾏内存申请，该内存即为⾃由存储区。

⽽堆是操作系统中的术语，是操作系统所维护的⼀块特殊内存，⽤于程序的内存动态分配，C语⾔使⽤malloc从堆上分配内存，使⽤free释放已分配的对应内存。

⾃由存储区不等于堆，如上所述，布局new就可以不位于堆中7. 调⽤函数使⽤new操作符来分配对象内存时会经历三个步骤：第⼀步：调⽤operator new 函数（对于数组是operator new[]）分配⼀块⾜够⼤的，原始的，未命名的内存空间以便存储特定类型的对象。