new，malloc，GlobalAlloc具体解释

WINDOWS下最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是栈，而是直接在进程的地址空间中保留一快内存。尽管用起来最不方便。

可是速度快，也最灵活

new，malloc，GlobalAlloc具体解释

同样点：都可用于申请动态内存和释放内存

不同点：

（1）操作对象有所不同。

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

对于非内部数据类的对象而言。光用maloc/free无法满足动态对象的要求。

对象在创建的同一时候要自己主动运行构造函数，对象消亡之前要自己主动运行析构函数。因为malloc/free是库函数而不是运算符，不在编译器控制权限之内，不可以把运行构造函数和析构函数的任务强加malloc/free。

（2）使用方法上也有所不同。

函数malloc 的原型例如以下：

void * malloc(size_t size);

用malloc 申请一块长度为length 的整数类型的内存，程序例如以下：

int *p = (int *) malloc(sizeof(int) * length);

我们应当把注意力集中在两个要素上：“类型转换”和“sizeof”。

1、malloc 返回值的类型是void *。所以在调用malloc时要显式地进行类型转换。

2、 malloc 函数本身并不识别要申请的内存是什么类型，它仅仅关心内存的总字节数。

函数free 的原型例如以下：

void free( void * memblock );

为什么free 函数不象malloc 函数那样复杂呢？这是由于指针p 的类型以及它所指的内存的容量事先都是知道的，语句free(p)能正确地释放内存。假设p是NULL 指针，那么free对p不管操作多少次都不会出问题。假设p不是NULL 指针，那么free 对p连续操作两次就会导致程序执行错误。

new/delete 的使用要点：

运算符new使用起来要比函数malloc简单得多。比如：

int *p1 = (int *)malloc(sizeof(int) * length);

int *p2 = new int[length];

这是由于new 内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言，new在创建动态对象的同一时候完毕了初始化工作。假设对象有多个构造函数。那么new的语句也能够有多种形式。

假设用new 创建对象数组，那么仅仅能使用对象的无參数构造函数。

比如

Obj *objects = new Obj[100];       // 创建100个动态对象

不能写成

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

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

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

delete objects; // 错误的使用方法，相当于delete objects[0]，漏掉了另外99个对象。

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

1、new自己主动计算须要分配的空间。而malloc须要手工计算字节数

        2、new是类型安全的，而malloc不是。比方：

                 int* p= new float[2]; // 编译时指出错误

                 int* p= malloc(2*sizeof(float)); // 编译时无法指出错误

          new operator 由两步构成。各自是 operator new和 construct

        3、operator new相应于malloc。但operator new能够重载，能够自己定义内存分配策略，甚至不做内存分配，甚至分配到非内存设备上。而malloc无能为力

        4、new将调用constructor。而malloc不能；delete将调用destructor，而free不能。

        5、malloc/free要库文件支持，new/delete则不要。

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

1、本质差别

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

对于用户自己定义的对象而言，用maloc/free无法满足动态管理对象的要求。对象在创建的同一时候要自己主动运行构造函数，对象在消亡之前要自己主动运行析构函数。

因为malloc/free是库函数而不是运算符。不在编译器控制权限之内，不可以把运行构造函数和析构函数的任务强加于malloc/free。因此C++须要一个能完毕动态内存分配和初始化工作的运算符new。以及一个能完毕清理与释放内存工作的运算符delete。

[cpp] view plaincopy

1.  class Obj {

2.  public:

3.      Obj( ){ cout  <<  "Initialization"  <<  endl; }

4.      ~ Obj( ) { cout  <<  "Destroy" <<  endl; }

5.      void Initialize( ) { cout  <<  "Initialization"  <<  endl; }

6.      void  Destroy( ) { cout  <<  "Destroy"  <<  endl; }

7.  }obj;

8.

9.  void  UseMallocFree( ) {

10.     Obj   * a  =  (Obj  *) malloc( sizeof ( obj ) );    //  allocate memory    a -> Initialize();                                    //  initialization    // …

11.     a -> Destroy();                                        // deconstruction   free(a);                                               // release memory  }

12. void  UseNewDelete( void ){

13.     Obj   * a  =   new  Obj;

14.     // …

15.     delete a;

16. }

类Obj的函数Initialize实现了构造函数的功能，函数Destroy实现了析构函数的功能。函数UseMallocFree中，因为malloc/free不能运行构造函数与析构函数，必须调用成员函数Initialize和Destroy来完毕“构造”与“析构”。所以我们不要用malloc/free来完毕动态对象的内存管理，应该用new/delete。因为内部数据类型的“对象”没有构造与析构的过程。对它们而言malloc/free和new/delete是等价的。

2、联系

既然new/delete的功能全然覆盖了malloc/free，为什么C++还保留malloc/free呢？由于C++程序常常要调用C函数，而C程序仅仅能用malloc/free管理动态内存。假设用free释放“new创建的动态对象”，那么该对象因无法运行析构函数而可能导致程序出错。假设用delete释放“malloc申请的动态内存”。理论上讲程序不会出错，可是该程序的可读性非常差。所以new/delete、malloc/free必须配对使用。

常见的内存错误及对策例如以下：

1. 内存分配未成功，却使用了它。

　　经常使用解决的方法是，在使用内存之前检查指针是否为NULL.假设是用malloc或new来申请内存。应该用if（p==NULL）或if（p！=NULL）进行防错处理。

2.内存分配尽管成功，可是尚未初始化就引用它。

　　犯这样的错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误（比如数组）。内存的缺省初值到底是什么并没有统一的标准，虽然有些时候为零值。

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

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

刚開始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。动态内存的申请与释放必须配对。程序中malloc与free的使用次数一定要同样。否则肯定有错误（new/delete同理）。

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

「规则1」用malloc或new申请内存之后，应该马上检查指针值是否为NULL.防止使用指针值为NULL的内存

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

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

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

　　「规则5」用free或delete释放了内存之后。马上将指针设置为NULL，防止产生“野指针”。

二。具体解释new，malloc。GlobalAlloc

1.  new使用方法：

1>     开辟单变量地址空间

1）new int； //开辟一个存放数组的存储空间。返回一个指向该存储空间的地址。

int*a = newint即为将一个int类型的地址赋值给整型指针a.

2）int *a = new int（5）作用同上，可是同一时候将整数赋值为5

2>    开辟数组空间

　　一维： int *a = new int[100]；开辟一个大小为100的整型数组空间

delete使用方法：

1> int *a = new int；

delete a。  //释放单个int的空间

2>int *a = new int[5]。

delete [] a； //释放int数组空间

　　要訪问new所开辟的结构体空间。无法直接通过变量名进行，仅仅能通过赋值的指针进行訪问。

　　用new和delete能够动态开辟，撤销地址空间。在编程序时。若用完一个变量（通常是临时存储的数组），下次须要再用，但却又想省去又一次初始化的功夫，能够在每次開始使用时开辟一个空间，在用完后撤销它。

2. malloc原型：externvoid *malloc（unsignedint num_bytes）；

使用方法：＃include <malloc.h>或＃include<stdlib.h>功能：分配长度为num_bytes字节的内存块说明：假设分配成功则返回指向被分配内存的指针，否则返回空指针NULL.

malloc的语法是：指针名=（数据类型*）malloc（长度）。

C。C++规定，void*类型能够强制转换为不论什么其他类型的指针。

malloc（）函数的工作机制malloc函数的实质体如今。它有一个将可用的内存块连接为一个长长的列表的所谓空暇链表。调用malloc函数时。它沿连接表寻找一个大到足以满足用户请求所须要的内存块。然后，将该内存块一分为二（一块的大小与用户请求的大小相等。还有一块的大小就是剩下的字节）。接下来，将分配给用户的那块内存传给用户，并将剩下的那块（假设有的话）返回到连接表上。

调用free函数时，它将用户释放的内存块连接到空暇链上。到最后，空暇链会被切成非常多的小内存片段。假设这时用户申请一个大的内存片段，那么空暇链上可能没有能够满足用户要求的片段了。于是，malloc函数请求延时，并開始在空暇链上翻箱倒柜地检查各内存片段，对它们进行整理，将相邻的小空暇块合并成较大的内存块。

　　和new的不同从函数声明上能够看出。malloc和 new 至少有两个不同： new返回指定类型的指针。而且能够自己主动计算所须要大小。比方：int*p。p = newint； //返回类型为int*类型（整数型指针），分配大小为sizeof（int）；或：int*parr；parr= new int [100]；//返回类型为 int*类型（整数型指针），分配大小为sizeof（int） * 100；而 malloc则必须由我们计算要字节数，而且在返回后强行转换为实际类型的指针。

　　第二、函数的实參为 sizeof（int），用于指明一个整型数据须要的大小。假设你写成：int* p= （int *） malloc（1）；代码也能通过编译。但其实仅仅分配了1个字节大小的内存空间。当你往里头存入一个整数，就会造成的结果是后面的内存中原有数据内容所有被清空。

3.  GlobalAlloc

VC中关于GlobalAlloc。GlobalLock，GlobalUnLock，GlobalFree

　　调用GlobalAlloc函数分配一块内存，该函数会返回分配的内存句柄。

　　调用GlobalLock函数锁定内存块，该函数接受一个内存句柄作为參数。然后返回一个指向被锁定的内存块的指针。您能够用该指针来读写内存。

　　调用GlobalUnlock函数来解锁先前被锁定的内存。该函数使得指向内存块的指针无效。

　　调用GlobalFree函数来释放内存块。您必须传给该函数一个内存句柄。

GlobalAlloc说明分配一个全局内存块返回值Long。返回全局内存句柄。零表示失败。会设置GetLastError參数表參数类型及说明wFlagsLong，对分配的内存类型进行定义的常数标志，例如以下所看到的：GMEM_FIXED分配一个固定内存块GMEM_MOVEABLE分配一个可移动内存块GMEM_DISCARDABLE分配一个可丢弃内存块GMEM_NOCOMPACT堆在这个函数调用期间不进行累积GMEM_NODISCARD函数调用期间不丢弃不论什么内存块GMEM_ZEROINIT新分配的内存块所有初始化成零dwBytesLong。要分配的字符数

GlobalLock函数功能描写叙述：锁定一个全局的内存对象，返回指向该对象的第一个字节的指针函数原型：LPVOIDGlobalLock（HGLOBAL hMem ）

　　參数：hMem：全局内存对象的句柄。这个句柄是通过GlobalAlloc或GlobalReAlloc来得到的返回值：调用成功，返回指向该对象的第一个字节的指针调用失败，返回NULL，能够用GetLastError来获得出错信息注意：调用过GlobalLock锁定一块内存区后，一定要调用GlobalUnlock来解锁

GlobalUnlock函数功能描写叙述：解除被锁定的全局内存对象函数原型：BOOLGlobalUnlock（HGLOBAL hMem ）；參数：hMem：全局内存对象的句柄返回值：非零值。指定的内存对象仍处于被锁定状态0，函数运行出错，能够用GetLastError来获得出错信息。假设返回NO_ERROR，则表示内存对象已经解锁了注意：   这个函数实际上是将内存对象的锁定计数器减一，假设计数器不为0。则表示运行过多个GlobalLock

　　函数来对这个内存对象加锁。须要相应数目的GlobalUnlock函数来解锁。

假设通过GetLastError函数返回错误

　　码为ERROR_NOT_LOCKED，则表示未加锁或已经解锁。

　　演示样例：// Malloc memory hMem =GlobalAlloc（GMEM_MOVEABLE| GMEM_DDESHARE，nSize）；//Lock memory pMem = （BYTE*）GlobalLock（hMem）。……

// Unlock memory GlobalUnlock（hMem）；GlobalFree（hMem）；

　　三总结

　　时过境迁。其现场已非出现故障时的现场了，这给调试内存问题带来了非常大的难度。

下载Windows Debug工具， http://www.microsoft.com/whdc/devtools/debugging/default.mspx安装后。使用当中的gflags.exe工具打开PageHeap。gflags-p
/enable MainD.exe /full又一次使用VS用调试方式执行，非常快就找到了出错位置，由于在某个静态函数中笔误导致

　　在编写稳定的服务器程序时，这个工具尤为实用。

參考文献及网页地址：

1. http://www.bccn.net/Article/kfyy/cjj/jszl/200607/4172.html

2.http://www.7880.com/Info/Article-8282a500.html C++内存管理具体解释

5.http://www.cnblogs.com/howareyou586/archive/2008/11/06/1328353.html关于GlobalAlloc，GlobalLock，GlobalUnLock

1. 首先我们来看HeapAlloc：MSDN上的解释为：HeapALloc是从堆上分配一块内存，且分配的内存是不可移动的（即假设没有连续的空间能满足分配的大小，程序不能将其它零散的空间利用起来，从而导致分配失败）。该分配方法是从一指定地址開始分配，而不像GloabalAlloc是从全局堆上分配，这个有可能是全局，也有可能是局部。函数原型为：LPVOID HeapAlloc（HANDLEhHeap，DWORDdwFlags，SIZE_TdwBytes）；hHeap是进程堆内存開始位置。

dwFlags是分配堆内存的标志。

包含HEAP_ZERO_MEMORY，即使分配的空间清零。

dwBytes是分配堆内存的大小。

　　其相应的释放空间函数为HeapFree.

2. 再看GlobalAlloc：该函数用于从全局堆中分配出内存供程序使用，函数原型为：HGLOBALGlobalAlloc（UINTuFlags，SIZE_TdwBytes）；uFlags參数含义GHND  GMEM_MOVEABLE和GMEM_ZEROINIT的组合GMEM_FIXED  分配固定内存，返回值是一个指针GMEM_MOVEABLE  分配活动内存，在Win32中。内存块不能在物理内存中移动，但能在默认的堆中移动。返回值是内存对象的句柄。用函数GlobalLock可将句柄转化为指针GMEM_ZEROINIT  将内存内容初始化为零GPTR  GMEM_FIXED和GMEM_ZEROINIT的组合普通情况下我们在编程的时候，给应用程序分配的内存都是能够移动的或者是能够丢弃的，这样能使有限的内存资源充分利用，所以，在某一个时候我们分配的那块内存的地址是不确定的，由于他是能够移动的。所以得先锁定那块内存块。这儿应用程序须要调用API函数GlobalLock函数来锁定句柄。例如以下：lpMem=GlobalLock（hMem）；这样应用程序才干存取这块内存。所以我们在使用GlobalAllock时。通常搭配使用GlobalLock。当然在不使用内存时，一定记得使用GlobalUnlock，否则被锁定的内存块一直不能被其它变量使用。

GlobalAlloc相应的释放空间的函数为GlobalFree.

3.LocalAlloc：该函数用于从局部堆中分配内存供程序使用，函数原型为：HLOCALLocalAlloc（UINTuFlags。SIZE_TuBytes）；參数同GlobalAlloc.在16位Windows中是有差别的，由于在16位windows用一个全局堆和局部堆来管理内存，每个应用程序或dll装入内存时。代码段被装入全局堆。而系统又为每个实例从全局堆中分配了一个64kb的数据段作为该实例的局部堆，用来存放应用程序的堆栈和全部全局或静态变量。

而LocalAlloc/GlobalAlloc就是分别用于在局部堆或全局堆中分配内存。

　　因为每一个进程的局部堆非常小，所以在局部堆中分配内存会受到空间的限制。但这个堆是每一个进程私有的，相对而言分配数据较安全，数据訪问出错不至于影响到整个系统。

　　而在全局堆中分配的内存是为各个进程共享的，每一个进程仅仅要拥有这个内存块的句柄都能够訪问这块内存。可是每一个全局内存空间须要额外的内存开销。造成分配浪费。并且一旦发生严重错误，可能会影响到整个系统的稳定。

　　只是在Win32中。每一个进程都仅仅拥有一个省缺的私有堆。它仅仅能被当前进程訪问。应用程序也不可能直接訪问系统内存。

所以在Win32中全局堆和局部堆都指向进程的省缺堆。用LocalAlloc/GlobalAlloc分配内存没有不论什么差别。甚至LocalAlloc分配的内存能够被GlobalFree释放掉。所以在Win32下编程，无需注意Local和Global的差别，一般的内存分配都等效于HeapAlloc（GetProcessHeap（），……）。

LocalAlloc相应的释放函数为LockFree.

4.VirtualAlloc：该函数的功能是在调用进程的虚地址空间，预定或者提交一部分页。假设用于内存分配的话，而且分配类型未指定MEM_RESET。则系统将自己主动设置为0；其函数原型：LPVOIDVirtualAlloc（LPVOIDlpAddress。// region to reserve or commit SIZE_T dwSize， // size of region DWORDflAllocationType，// type of allocation DWORD flProtect
// type of access protection）；VirtualAlloc能够通过并行多次调用提交一个区域的部分或所有来保留一个大的内存区域。多重调用提交同一块区域不会引起失败。这使得一个应用程序保留内存后能够任意提交将被写的页。

当这样的方式不在有效的时候，它会释放应用程序通过检測被保留页的状态看它是否在提交调用之前已经被提交。

VirtualAlloc相应的释放函数为VirtualFree.

[new，malloc，GlobalAlloc具体解释]