Why are the terms “automatic” and “dynamic” preferred over the terms “stack” and “heap” in C++ memory management?

by

Automatic tells me something about the lifetime of an object: specifically that it is bound automatically to the enclosing scope, and will be destroyed automatically when that scope exits.

Dynamic tells me that the lifetime of an object is not controlled automatically by the compiler, but is under my direct control.

Stack is an overloaded name for a type of container, and for the related popular instruction pointer protocol supported by common call and ret instructions. It doesn’t tell me anything about the lifetime of an object, except through a historical association to object lifetimes in C, due to popular stack frame conventions.
Note also that in some implementations, thread-local storage is on the stack of a thread, but is not limited to the scope of any single function.

Heap is again an overloaded name, indicating either a type of sorted container or a free-store management system. This is not the only free store available on all systems, and nor does it tell me anything concrete about the lifetime of an object allocated with new.

More Related Contents:

  1. When vectors are allocated, do they use memory on the heap or the stack?
  2. Object creation on the stack/heap?
  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. How to debug why my C code causes a segmentation fault? [closed]
  13. Why should C++ programmers minimize use of ‘new’?
  14. Stack, Static, and Heap in C++
  15. What is memory fragmentation?
  16. Calling delete on variable allocated on the stack
  17. Which is faster: Stack allocation or Heap allocation
  18. Arrays, heap and stack and value types
  19. Why are two different concepts both called “heap”? [duplicate]
  20. Memory allocation: Stack vs Heap?
  21. Is there a reason to call delete in C++ when a program is exiting anyway?
  22. Fields of class, are they stored in the stack or heap?
  23. Why would you ever want to allocate memory on the heap rather than the stack? [duplicate]
  24. g++ variable size array no warning?
  25. Critique my non-intrusive heap debugger
  26. Is there a limit of stack size of a process in linux
  27. Size of stack and heap memory [duplicate]
  28. Linux Allocator Does Not Release Small Chunks of Memory
  29. How to prevent an object being created on the heap?
  30. What’s the advantage of using std::allocator instead of new in C++?

Leave a Comment