152

Dynamic allocations with new/delete are said to take place on the free-store,
while malloc/free operations use the heap.

I'd like to know if there is an actual difference, in practice.
Do compilers make a distinction between the two terms? (Free store and Heap, not new/malloc)

Nick Dandoulakis
  • 42,588
  • 16
  • 104
  • 136
  • 1
    On embedded system, yes there may be a distinction. On most (all?) personal computers, the new/delete free-store is a heap. (On my machine, new/delete, new[]/delete[], and malloc/free have separate heaps. But they're all heaps.) – Eljay Aug 31 '21 at 13:08

7 Answers7

95

For C++, the difference between the free store and the heap has become purely conceptual. Like a jar for collecting bugs, and one for collecting cookies. One is labeled one way, the other another. This designation is meant to drive home the point that you NEVER mix "new" and "delete" with "malloc", "realloc", or "free" (or bit level sets for that matter).

During interviews it's good to say that "new and delete use the free store, malloc and free use the heap; new and delete call the constructor and destructor, respectively, however malloc and free do not." Yet, you will often hear that the memory segments are really in the same area - however, that CAN be compiler specific, that is to say, it is possible that both can designate different memory spaces as pools (not sure why it would be, though).

Waqar
  • 8,558
  • 4
  • 35
  • 43
Kit10
  • 1,345
  • 11
  • 12
91

See http://www.gotw.ca/gotw/009.htm; it can describe the differences between the heap and the free-store far better than I could:

Free-store:

The free store is one of the two dynamic memory areas, allocated/freed by new/delete. Object lifetime can be less than the time the storage is allocated; that is, free store objects can have memory allocated without being immediately initialized, and can be destroyed without the memory being immediately deallocated. During the period when the storage is allocated but outside the object's lifetime, the storage may be accessed and manipulated through a void* but none of the proto-object's nonstatic members or member functions may be accessed, have their addresses taken, or be otherwise manipulated.

Heap:

The heap is the other dynamic memory area, allocated/freed by malloc/free and their variants. Note that while the default global new and delete might be implemented in terms of malloc and free by a particular compiler, the heap is not the same as free store and memory allocated in one area cannot be safely deallocated in the other. Memory allocated from the heap can be used for objects of class type by placement-new construction and explicit destruction. If so used, the notes about free store object lifetime apply similarly here.

Michael Koval
  • 8,207
  • 5
  • 42
  • 53
  • 28
    I disagree. The word "heap" in the context of dynamic allocation is used neither by the C++ standard nor C99 (I don't have C89 to which C++ refers, feel free to correct me if it uses the word). I couldn't find the date the GotW in question was published, but since it talks about the draft, it's obviously pre-standard. – avakar Aug 29 '09 at 08:40
  • 6
    This is all the question of terminology, imho. Say, mr. Stroustrup does not distinguish 'heap' and 'free store': http://www.stroustrup.com/Programming/17_free_store.ppt, slide 12. 'Heap' was used as a synonym of dynamic memory long ago before C++, since Lisp time (1960s) which used heap data structure for memory allocation. – Spock77 Jan 21 '16 at 04:23
  • 3
    I generally think of the heap (via maloc/free) as a sort of 'raw' material supplier. You ask for a chunk of memory you get it no frills. You have to build any structures yourself. The Free Store (new/delete) is more like a 'finished goods' supplier. You ask for an object and it gets allocated some space, and the object it built up and prepared for your use. When it is finished with it gets nicely cleaned up. – Anshuman Kumar Jun 08 '20 at 07:29
37

Mike Koval's answer covers the theory quite well. In practice, however, they are almost always the same region of memory -- in most cases if you dig into the compiler's implementation of new, you'll find it calls malloc().

In other words: from the machine's point of view, heap and free store are the same thing. The distinction exists inside the compiler.

To make things even more confusing, before the advent of C++ we said "heap" to mean what is now called "free store."

Crashworks
  • 40,496
  • 12
  • 101
  • 170
  • Than calling `new + delete` is equivalent to calling `new + destructor + free`? – joepol Jan 19 '22 at 08:17
  • 1
    It's undefined behavior, because the standard doesn't say anything about whether `new` and `malloc()` draw from the same heap. In practice, most implementations of `new` just call `malloc()` underneath. But you can't count on that. – Crashworks Jan 19 '22 at 23:18
7

The term "heap" may also refer to a particular data structure, but in the context of the C++ malloc, free, new, and delete operations the terms "heap" and "free store" are used more or less interchangeably.

Jim Lewis
  • 43,505
  • 7
  • 82
  • 96
4

Free Store is a pool of un-allocated heap memory given to a program that is used by the program for dynamic allocation during the execution of program. Every program is provided with a pool of un-allocated heap memory that it may utilize during the execution. This pool of available memory is referred to as free store of the program. The allocated free store memory is unnamed.

Sudipto
  • 390
  • 1
  • 3
  • 18
3

I don't recall the standard ever mentioning the word heap, except in the descriptions of heap functions like push_heap et al. All dynamic allocations are performed on the free-store.

avakar
  • 32,009
  • 9
  • 68
  • 103
3

Heap and free-store aren't supposed to be interoperable. In constrained contextes like in AVR 8-bit micro controllers with c++11 Standard Library, they cannot even be used in the same program. Free store and heap do their allocations in the same memory space, overwriting each other structures and data. In this context, Free store is different and incompatible with Heap because the "new/delete free store library" is simpler (and quicker) than the "Malloc/free/realloc/calloc heap library" and thus provides huge memory usage gains to the C++ embedded programmer (in a context where you have only 512 bytes of RAM).

See 8-bit c++11/14 Standard Library at https://github.com/ambroise-leclerc/ETL/tree/master/libstd

Ambroise Leclerc
  • 39
  • 3