Class members and explicit stack/heap allocation

by

I think that you are confusing “stack/heap allocation” and “automatic variable”.

Automatic variables are automatically destroyed when going out of context.

Stack allocation is the fact that the memory is allocated on the execution stack. And variable allocated on the stack are automatic variables.

Also, members are automatic variables whose destructors get called when its owner is destroyed. In the case of pointers, they are destroyed but not the underlying object, you have to explicitly call delete. To make sure that the underlying object is destroyed you have to use smart or unique pointers.

To put it another way: variables/members that you have to call delete on, are not automatic variables.

Lastly, member of a class are allocated on the same memory segment of the its owner.

In you code:

  • A.m_B is an automatic variable. If A is on the stack so is B and if A is on the heap so is B.
  • B.m_i and D.m_i are an automatic variables and will be allocated on the same memory segment of their owner
  • The pointer C.m_D is an automatic variable, but the pointed object of type D is not, you have to explicitly call delete on the pointer to delete the underlying object. So, the pointer C.m_D is allocated on the same memory segment, but not the underlying objet. It’s cleary allocated by new and will be on the heap.

So:

  • Case 1: Everything is on the stack and automatic (ie: destroyed automatically).
  • Case 2: myA2 is on the heap and not automatic (you have to delete myA2). Its member m_B2 is an automatic variable that will be destroyed when myA2 is destroyed. Also since myA2 is on the heap, m_B, like any member of a class, is in the same memory space the heap too.
  • Case 3: myC1 is on the stack and is an automatic variable, The pointer to m_D is on the stack too, but not the object pointed by m_D which is allocated by new on the heap.
  • Case 4: Same as case3 but myC2 is on the heap and is not automatic. So you have to delete myC2 (which will delete m_D).

More Related Contents:

  1. Why would you ever want to allocate memory on the heap rather than the stack? [duplicate]
  2. How is heap and stack memories managed, implemented, allocated?
  3. Dynamic memory allocation in game server [closed]
  4. Why should C++ programmers minimize use of ‘new’?
  5. When and why will a compiler initialise memory to 0xCD, 0xDD, etc. on malloc/free/new/delete?
  6. What is memory fragmentation?
  7. Which is faster: Stack allocation or Heap allocation
  8. When vectors are allocated, do they use memory on the heap or the stack?
  9. Arrays, heap and stack and value types
  10. Proper stack and heap usage in C++?
  11. Is there a reason to call delete in C++ when a program is exiting anyway?
  12. Object creation on the stack/heap?
  13. General guidelines to avoid memory leaks in C++ [closed]
  14. What is the difference between “new” and “malloc” and “calloc” in C++? [duplicate]
  15. Allocating more memory than there exists using malloc
  16. Why not use pointers for everything in C++?
  17. Fields of class, are they stored in the stack or heap?
  18. How do you determine the size of an object in C++?
  19. Are there stackless or heapless implementation of C++?
  20. Does this type of memory get allocated on the heap or the stack?
  21. Is accessing data in the heap faster than from the stack?
  22. Size of stack and heap memory [duplicate]
  23. Is global memory initialized in C++?
  24. Linux Allocator Does Not Release Small Chunks of Memory
  25. What does “Memory allocated at compile time” really mean?
  26. What happens if I increment an array variable?
  27. How to find if a variable is allocated in stack or heap?
  28. Are global variables in C++ stored on the stack, heap or neither of them?
  29. Why do we even need the “delete[]” operator?
  30. C++ delete does not free all memory (Windows)

Leave a Comment