new/delete、malloc/free、GlobalAlloc/HeapAlloc/VirtualAlloc、GlobalLock/GlobalUnlock等

 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则简单得多。

所以我们不要企图用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也一样。

全局内存对象使用GlobalAlloc函数分配,在Windows   3.X的时代，分配的内存可以有两种，全局的和局部的，例如GlobalAlloc和LocalAlloc。但在Win32的时代这些函数已经被废弃了，现在的内存只有一种就是虚存。在Win32中所有的进程所使用的内存区域是相互隔离的，每个进程都拥有自己的地址空间。而且系统使用了页面交换功能，就是利用磁盘空间来模拟RAM，在RAM中数据不使用时将会被交换到磁盘，在需要时将会被重新装入RAM。  

 

在C++里使用堆内存分配是使用 HeapAlloc 函数来实现的，也就是实现 new 操作符分配内存时会调这个函数。

VirtualAlloc一次分配1PAGE以上的RAM。每次分配都是PAGE的整数倍。你不会想为了分配1个BYTE的空间而浪费剩下的4095字节。OK。你可以自己写算法,多分配几PAGE。然后每次分配少量数据时就从那几PAGE中划分出来。什么? 你笨到不会写分配算法? 好吧，KERNEL32给你一个解决办法。用HeapAlloc/GlobalAlloc分配RAM。这样, KERNEL32帮你完成分配动作， 并且尽量在减少用于跟踪空闲区域和已占用区域消耗的数据结构。很久以前也有个产品叫做WINDOWS。那时候的WINDOWS是16BIT的。地址空间有些紧俏。有钱不够。还需要粮票肉票才能拿到。你已经调用GlobalAlloc和已经出钱的性质一样。GlobalAlloc还不够。有时候需要GlocalLock才能确定你的东西确实可以拿到手。不然你的指针会非法。被充公。你的应用会被杀头。扯远了。后来OS进化了。觉得可以取消粮票肉票。但是你必须用新版钞票才行。那就是HeapAlloc。只要市场上的RAM数量没问题
。你的HeapAlloc没问题。那就总能拿到东西。但是, 你总不能说有了2000版的钞票, 那80版的马上作废啊。那GlobalAlloc也只好继续流通下去。至于可以流通到什么时候。没人知道。

GlobalAlloc和LocalAlloc都是Windows系统提供的内存分配函数，他们的区别源于16位代码时代，那时没有不同的进程内存空间，GlobalAlloc是在全局的、公用的远堆上分配，LocalAlloc则在任务自己的近堆上分配。在Win32平台下这两个函数是完全相同的，都是在进程自己的内存空间中分配，Lock之后的结果是普通指针（32位近指针）。new与它们的区别未免太大，因为与C++的构造函数和异常机制有关。一般编译器中的new都是用malloc来分配内存的。用malloc与其它两个函数比较应该更合理。一般malloc的实现并不是从系统的堆中分配的，而是从编译器连接的运行库自己管理的堆中，在Win32平台上的开发工具的编译结果中，通常是用HeapCreate创建一个堆，用HeapAlloc和HeapRealloc维护堆的空间增长，在最后用HeapDestroy删除堆。而在用malloc分配、用free释放时则由运行库的代码负责从这个堆中分配空间和向这个堆中归还空间，并维护这个堆中的数据结构。由于malloc堆的管理是由运行库自己管理的，所在当我们使用静态运行库时，如果在一个DLL中用malloc分配了内存而在另一个DLL中用
free去释放它，通常都会产生问题，这是因为每个DLL都连接了一份运行库的代码，从而也都有一个自己的局部堆，而在用free释放时它会假设这块内存是在自己的堆中分配的，从而导致错误。而通过GlobalAlloc和LocalAlloc分配的内存不存在这个问题。

HeapCreate就已经完成了创建堆的操作，HeapAlloc、HeapRealloc和HeapFree都是从这个堆中分配、释放内存的函数。也就是说，Windows系统其实已经为我们提供了完整的一套使用自己的局部堆的操作，不过没有看到指定分配策略的方法。根据编译器提供的源代码来看，VC中的malloc、realloc和free等函数主要功能就是用这几个API函数来实现的，而BC中的实现相当复杂，似乎是维护了一套自己的逻辑。
4000
据说BC的内存分配比VC快，大概就是这个原因了。

 

1. 首先我们来看HeapAlloc：

MSDN上的解释为：HeapALloc是从堆上分配一块内存，且分配的内存是不可移动的（即如果没有连续的空间能满足分配的大小，程序不能将其他零散的空间利用起来，从而导致分配失败），该分配方法是从一指定地址开始分配，而不像GloabalAlloc是从全局堆上分配，这个有可能是全局，也有可能是局部。函数原型为：

LPVOID

HeapAlloc(

    HANDLE hHeap,

    DWORD dwFlags,

    SIZE_T dwBytes

    );

hHeap是进程堆内存开始位置。

dwFlags是分配堆内存的标志。包括HEAP_ZERO_MEMORY，即使分配的空间清零。

dwBytes是分配堆内存的大小。

其对应的释放空间函数为HeapFree。

2. 再看GlobalAlloc：该函数用于从全局堆中分配出内存供程序使用，函数原型为：

HGLOBAL GlobalAlloc(

    UINT uFlags,

    SIZE_T dwBytes

);

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：该函数用于从局部堆中分配内存供程序使用，函数原型为：

HLOCAL LocalAlloc(

    UINT uFlags,

    SIZE_T uBytes

);

参数同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;其函数原型：

LPVOID VirtualAlloc(

　　LPVOID lpAddress, // region to reserve or commit

　　SIZE_T dwSize, // size of region

　　DWORD flAllocationType, // type of allocation

　　DWORD flProtect // type of access protection

　　);

VirtualAlloc可以通过并行多次调用提交一个区域的部分或全部来保留一个大的内存区域。多重调用提交同一块区域不会引起失败。这使得一个应用程 序保留内存后可以随意提交将被写的页。当这种方式不在有效的时候，它会释放应用程序通过检测被保留页的状态看它是否在提交调用之前已经被提交。

VirtualAlloc对应的释放函数为VirtualFree。

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

6． new：new/delete是C++的运算符。可用于申请动态内存和释放内存。C++语言需要一个能完成动态内存分配和初始化工作的运算符new， 以一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。C++程序经常要调用C函数，而C程序只能用malloc /free管理动态内存。new 是个操作符,和什么"+"，"-"，"="...有一样的地位。

        malloc是个分配内存的函数,供你调用的。

        new是保留字，不需要头文件支持。

        malloc需要头文件库函数支持new 建立的是一个对象,

        malloc分配的是一块内存。

        new建立的对象你可以把它当成一个普通的对象,用成员函数访问,不要直接访问它的地址空间

        malloc分配的是一块内存区域，就用指针访问好了，而且还可以在里面移动指针。

内存泄漏对于malloc或者new都可以检查出来的，区别在于new可以指明是那个文件的那一行，而malloc没有这些信息。new可以认为是malloc加构造函数的执行。new出来的指针是直接带类型信息的。而malloc返回的都是void指针。

 

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

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

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

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

GlobalAlloc

函数原型：

GlobalAlloc(UINT uFLAG,DWORD dwBytes);

说明

分配一个全局内存块

返回值

Long，返回全局内存句柄。零表示失败。会设置GetLastError

参数表

参数 类型及说明

uFlags Long，对分配的内存类型进行定义的常数标志，如下所示：

             GMEM_FIXED 分配一个固定内存块

             GMEM_MOVEABLE 分配一个可移动内存块

             GMEM_DISCARDABLE 分配一个可丢弃内存块

             GMEM_NOCOMPACT 堆在这个函数调用期间不进行累积

             GMEM_NODISCARD 函数调用期间不丢弃任何内存块

             GMEM_ZEROINIT 新分配的内存块全部初始化成零

dwBytes Long，要分配的字符数

注解 

如指定了 GMEM_FIXED，那么返回值就是要使用的实际内存地址即指针（GlobalLock 会返回同样的值）——所以在使用固定内存块的时候不需要执行一个 GlobalLock/GlobalUnlock 操作

由于 Win32 采用了高级的内存管理方案，所以使用可移动的内存块并没有什么好处

用这个函数分配的内存块允许在8位边界以内

GlobalLock 

函数功能描述:锁定一个全局的内存对象，返回指向该对象的第一个字节的指针

函数原型：

LPVOID GlobalLock( HGLOBAL hMem )

参数：

hMem：全局内存对象的句柄。这个句柄是通过GlobalAlloc或GlobalReAlloc来得到的

返回值：

调用成功，返回指向该对象的第一个字节的指针

调用失败，返回NULL，可以用GetLastError来获得出错信息

注意：

调用过GlobalLock锁定一块内存区后，一定要调用GlobalUnlock来解锁。

GlobalUnlock

函数功能描述:解除被锁定的全局内存对象

函数原型：BOOL GlobalUnlock( HGLOBAL hMem );

参数：hMem：全局内存对象的句柄

返回值：

非零值，指定的内存对象仍处于被锁定状态

0，函数执行出错，可以用GetLastError来获得出错信息，如果返回NO_ERROR，则表示内存对象已经解锁了

注意：    这个函数实际上是将内存对象的锁定计数器减一，如果计数器不为0，则表示执行过多个GlobalLock函数来对这个内存对象加锁，需要对应数目的GlobalUnlock函数来解锁。

    如果通过GetLastError函数返回错误码为ERROR_NOT_LOCKED，则表示未加锁或已经解锁。