Object creation on the stack/heap?

by

Actually, neither statement says anything about heap or stack. The code

Object o;

creates one of the following, depending on its context:

  • a local variable with automatic storage,
  • a static variable at namespace or file scope,
  • a member variable that designates the subobject of another object.

This means that the storage location is determined by the context in which the object is defined. In addition, the C++ standard does not talk about stack vs heap storage. Instead, it talks about storage duration, which can be either automatic, dynamic, static or thread-local. However, most implementations implement automatic storage via the call stack, and dynamic storage via the heap.

Local variables, which have automatic storage, are thus created on the stack. Static (and thread-local) objects are generally allocated in their own memory regions, neither on the stack nor on the heap. And member variables are allocated wherever the object they belong to is allocated. They have their containing object’s storage duration.

To illustrate this with an example:

struct Foo {
    Object o;
};

Foo foo;

int main() {
    Foo f;
    Foo* p = new Foo;
    Foo* pf = &f;
}

Now where is the object Foo::o (that is, the subobject o of an object of class Foo) created? It depends:

  • foo.o has static storage because foo has static storage, and therefore lives neither on the stack nor on the heap.
  • f.o has automatic storage since f has automatic storage (= it lives on the stack).
  • p->o has dynamic storage since *p has dynamic storage (= it lives on the heap).
  • pf->o is the same object as f.o because pf points to f.

In fact, both p and pf in the above have automatic storage. A pointer’s storage is indistinguishable from any other object’s, it is determined by context. Furthermore, the initialising expression has no effect on the pointer storage.

The pointee (= what the pointer points to) is a completely different matter, and could refer to any kind of storage: *p is dynamic, whereas *pf is automatic.

More Related Contents:

  1. Why are the terms “automatic” and “dynamic” preferred over the terms “stack” and “heap” in C++ memory management?
  2. When vectors are allocated, do they use memory on the heap or the stack?
  3. Why not use pointers for everything in C++?
  4. Where are temporary object stored?
  5. Are there stackless or heapless implementation of C++?
  6. How is heap and stack memories managed, implemented, allocated?
  7. Is accessing data in the heap faster than from the stack?
  8. What happens if I increment an array variable?
  9. How to find if a variable is allocated in stack or heap?
  10. Class members and explicit stack/heap allocation
  11. Are global variables in C++ stored on the stack, heap or neither of them?
  12. Is there a difference between copy initialization and direct initialization?
  13. Does initialization entail lvalue-to-rvalue conversion? Is `int x = x;` UB?
  14. Which is faster: Stack allocation or Heap allocation
  15. Why aren’t pointers initialized with NULL by default?
  16. What are the advantages of list initialization (using curly braces)?
  17. Why are my struct’s members not properly initialised using `{}`? [duplicate]
  18. memset() or value initialization to zero out a struct?
  19. Are function static variables thread-safe in GCC?
  20. C++ where to initialize static const
  21. What is dynamic initialization of object in c++?
  22. Initializing container of unique_ptrs from initializer list fails with GCC 4.7
  23. Critique my non-intrusive heap debugger
  24. Value initialization and Non POD types
  25. Has the new C++11 member initialization feature at declaration made initialization lists obsolete?
  26. Member fields, order of construction
  27. Initialization difference with or without curly braces in C++
  28. Initializing an std::array of non-default-constructible elements?
  29. What is the order of evaluation in a member initializer list?
  30. C++ default initialization and value initialization: which is which, which is called when and how to reliably initialize a template-type member

Leave a Comment