When to use the stack vs the heap

In general, you should prefer allocating memory on the stack when possible. Stack allocation is faster and automatically managed.

Use stack allocation when:

• The lifetime of the object is tied to the current scope
• The size of the object is known at compile time and is not too large

Use heap allocation when:

• The object needs to outlive the current function
• The size of the object is not known at compile time
• The size of the object is too large for the stack

Here's an example illustrating both:

1#include <iostream>
2
3void func() {
4  // Allocated on the stack
5  int stackInt = 10;      
6
7  // Allocated on the heap
8  int* heapInt = new int(20);
9
10  // We must delete the heap-allocated variable
11  delete heapInt;              
12}  // stackInt is automatically deallocated here
13
14int main() {
15  int size;
16  std::cin >> size;
17
18  // Size not known at compile time
19  int* array = new int[size];
20  delete[] array;
21}

Remember, whenever you allocate memory on the heap with new, you are responsible for deallocating it with delete to avoid memory leaks.

In modern C++, you can often avoid making this decision by using standard library containers like std::vector, or smart pointers like std::unique_ptr and std::shared_ptr. These manage memory for you, with the memory for the actual data being allocated on the heap, but the bookkeeping handled automatically.