How do you manage memory in C++?

Managing memory in C++ is a critical skill, especially in game development, where performance and resource constraints are significant. C++ provides both automatic and manual memory management options. Here's a concise explanation suitable for someone interviewing at a FAANG company:

In C++, memory management involves allocating and deallocating memory in the stack and heap. The stack is used for static memory allocation, while the heap is used for dynamic memory allocation. C++ offers several tools and techniques for memory management, such as smart pointers, RAII (Resource Acquisition Is Initialization), and manual management with new and delete operators.

Key Talking Points:

• Automatic vs. Manual Memory Management:

  • Automatic: Stack allocation, limited size, faster.
  • Manual: Heap allocation, flexible size, requires careful management.

• Smart Pointers:

  • std::unique_ptr: Owns a resource exclusively.
  • std::shared_ptr: Allows shared ownership of a resource.
  • std::weak_ptr: Accesses a shared resource without owning it.

• RAII (Resource Acquisition Is Initialization):

  • Ensures resources are properly released when objects go out of scope.

• Manual Management:

  • Use new to allocate memory and delete to deallocate.
  • Be cautious of memory leaks and dangling pointers.

NOTES:

Reference Table:

Pseudocode:

Here's a brief example of using smart pointers for managing memory:

#include <iostream>
#include <memory>

class GameEntity {
public:
    GameEntity() { std::cout << "Entity created\n"; }
    ~GameEntity() { std::cout << "Entity destroyed\n"; }
};

int main() {
    {
        std::unique_ptr<GameEntity> entity = std::make_unique<GameEntity>();
        // Use entity...
    } // entity automatically destroyed here

    return 0;
}

Follow-Up Questions and Answers:

1. What are the common causes of memory leaks in C++?

   • Memory leaks occur when allocated memory is not deallocated. Common causes include forgetting to use delete on heap-allocated memory or failing to manage object ownership correctly with smart pointers.

2. How does RAII help in C++ memory management?

   • RAII ties resource management (including memory) to object lifetime. When an object goes out of scope, its destructor is automatically called, releasing resources and preventing leaks.

3. What are dangling pointers and how can they be avoided?

   • Dangling pointers refer to memory locations that have been deallocated. They can be avoided by setting pointers to nullptr after deletion or using smart pointers that automatically manage ownership and deallocation.