LocalAlloc Vs GlobalAlloc Vs malloc Vs new

Question

I have searched for this on various links, but still the doubt persist.

I do not understand the difference between LocalAlloc vs GlobalAlloc vs malloc vs new for memory allocation.

I have gone through this link of MSDN:

Please explain the following statement:

The malloc function has the disadvantage of being run-time dependent. The new operator has the disadvantage of being compiler dependent and language dependent

`LocalAlloc` and `LocalFree` are useful when you need to allocate memory in one module (DLL or EXE) and release it in a separate module. Unless you link both modules with the same MSVCRT DLL set, invoking `free` or `delete` will likely crash since the memory was malloc'd by a different runtime instance. Having `LocalFree` if often an easy story for API providers if they do not want to expose a deallocate function directly. — selbie, Dec 17 '15 at 05:36
https://learn.microsoft.com/en-us/windows/win32/memory/comparing-memory-allocation-methods — hookenz, Nov 24 '19 at 22:23

score 35 · Accepted Answer · edited May 31 '23 at 05:47

Excerpts from Raymond Chen's OldNewThing

Back in the days of 16-bit Windows, the difference was significant.

In 16-bit Windows, memory was accessed through values called “selectors”, each of which could address up to 64K. There was a default selector called the “data selector”; operations on so-called “near pointers” were performed relative to the data selector. For example, if you had a near pointer p whose value was 0x1234 and your data selector was 0x012F, then when you wrote *p, you were accessing the memory at 012F:1234. (When you declared a pointer, it was near by default. You had to say FAR explicitly if you wanted a far pointer.)

Important: Near pointers are always relative to a selector, usually the data selector.

The GlobalAlloc function allocated a selector that could be used to access the amount of memory you requested. You could access the memory in that selector with a “far pointer”. A “far pointer” is a selector combined with a near pointer. (Remember that a near pointer is relative to a selector; when you combine the near pointer with an appropriate selector, you get a far pointer.)

Every instance of a program and DLL got its own data selector, known as the HINSTANCE. Therefore, if you had a near pointer p and accessed it via *p from a program executable, it accessed memory relative to the program instance’s HINSTANCE. If you accessed it from a DLL, you got memory relative to your DLL’s HINSTANCE.

Therefore, that in 16-bit Windows, the LocalAlloc and GlobalAlloc functions were completely different! LocalAlloc returned a near pointer, whereas GlobalAlloc returned a selector.

Pointers that you intended to pass between modules had to be in the form of “far pointers” because each module has a different default selector. If you wanted to transfer ownership of memory to another module, you had to use GlobalAlloc since that permitted the recipient to call GlobalFree to free it.

Even in Win32, you have to be careful not to confuse the local heap from the global heap. Memory allocated from one cannot be freed on the other. All the weirdness about near and far pointers disappeared with the transition to Win32. But the local heap functions and the global heap functions are nevertheless two distinct heap interfaces.

Also, the link specified by you clearly says that,

Starting with 32-bit Windows, GlobalAlloc and LocalAlloc are implemented as wrapper functions that call HeapAlloc using a handle to the process's default heap, and HeapAlloc can be instructed to raise an exception if memory could not be allocated, a capability not available with LocalAlloc.

For your confusion on malloc vs new, Billy ONeal's answer summarizes that pretty clearly.

For the difference between malloc and HeapAlloc, David Heffernan's and Luis Miguel Huapaya's answer combined gives the perfect solution::

malloc is portable, part of the standard. malloc (and other C runtime heap functions) are module dependant, which means that if you call malloc in code from one module (i.e. a DLL), then you should call free within code of the same module or you could suffer some pretty bad heap corruption.
HeapAlloc is not portable, it's a Windows API function. Using HeapAlloc with GetProcessHeap instead of malloc, including overloading new and delete operators to make use of such, allow you to pass dynamically allocated objects between modules and not have to worry about memory corruption if memory is allocated in code of one module and freed in code of another module once the pointer to a block of memory has been passed across to an external module.

I think this is a good article (after all, I linked to it approximately 7 minutes before you posted this answer) but I don't think it answers the user's question, which is specifically talking about the language "run-time dependent" and "compiler and language dependent". — Billy ONeal, Dec 17 '15 at 05:18
Of course, your answer summarizes all. I have just put precise, relevant and short excerpts from that blog. — Abhineet, Dec 17 '15 at 05:22
no, I don't think the blog answers the user's question. The blog is about Global/LocalAlloc. The user's question is about malloc and new, of which the article says nothing. — Billy ONeal, Dec 17 '15 at 05:42
Thanks for that, your explanation is plain and simple. Very easy to grab on. People familiar with near and far pointers, would not even need to read the Raymond's blog. Respect. — Abhineet, Dec 17 '15 at 05:45
If you need to pass resources across module boundaries, the standard way would be to use the [IMalloc](https://msdn.microsoft.com/en-us/library/windows/desktop/ms678425.aspx) interface. Unless you cannot have a dependency on COM (like the Win32 API), which is why it uses the `LocalXxx` functions (e.g. [FormatMessage](https://msdn.microsoft.com/en-us/library/windows/desktop/ms679351.aspx)). — IInspectable, Dec 17 '15 at 11:18

Billy ONeal · Answer 2 · 2015-12-17T05:05:12.580

33

GlobalAlloc and LocalAlloc are old functions from the 16 bit era. The difference was that you sometimes had to be able to allocate memory only used in your segment (that used near pointers), and sometimes needed to allocate memory to be shared with other processes and segments on the system. Today, these guys forward in some form or another to the HeapXxx functions, such as HeapAlloc. If you're writing new code and need to avoid linking with the C runtime, you should use the HeapXxx functions instead. Of course, if you call any of these, your program will only compile and run on Windows.

malloc is "run-time dependent" in that using it requires that you link against the C run-time (CRT). The CRT is the library that contains all the other standard C library functions, like printf or qsort. You can write a plain Win32 API program without linking with this (but I honestly can't see why you'd want to do that in real software).

new is compiler dependent and language dependent in that they require a compiler that can compile C++. (And usually new is implemented in terms of malloc, so it'll probably require using the CRT as well)

edited Dec 17 '15 at 05:05

answered Dec 17 '15 at 04:58

Billy ONeal

104,103
58
317
552

1

Thanks Billy ONeal :). – User1234 Dec 17 '15 at 06:10
1

`new` can throw exceptions. Exception handling requires the CRT, when compiling with Visual Studio (and some other compilers as well). So even if `new` weren't implemented in terms of `malloc`, you'd still have a dependency on the CRT. – IInspectable Dec 17 '15 at 11:08
1

@IInspectable not necessarily; the user can override new to `terminate()` on allocation failure. – Billy ONeal Dec 17 '15 at 15:53
1

I took your *"usually `new` is implemented in terms of `malloc`"* to mean, that you are talking about the C++ Standard Library implementation, not a user-provided overload. – IInspectable Dec 17 '15 at 15:56
1

@IInspectable sure; but if you call the built in one, you already depend on the CRT, so the exceptions thing isn't really a big deal :) – Billy ONeal Dec 17 '15 at 16:03

LocalAlloc Vs GlobalAlloc Vs malloc Vs new

2 Answers2

Linked