Skip to main content

5.1.7. Pointers and Memory Management

You won’t need to write low-level memory code every day, but understanding how memory works under the hood is an important part of becoming a strong developer.

Most beginner-friendly languages like Python or JavaScript take care of memory management for you automatically — that’s called garbage collection. But as you move into more advanced roles, especially in systems programming or performance-critical applications (like game engines, operating systems, or databases), you’ll likely encounter languages where you have to manage memory yourself.

These include:

  • C / C++ – Manual memory allocation and pointers
  • Rust – Enforces memory safety through ownership rules rather than garbage collection
  • Go* – Has garbage collection, but gives you control over memory layout. Go's pointers are likely not the best way to learn about pointers.

Even if you don’t plan on writing C or Rust full-time, learning one of these languages will teach you how memory works — which will make you better at using all other languages too.

What Are Pointers?​

A pointer is just a variable storing the location of where some data is stored in memory. Instead of holding the actual value, it holds the address where that value is located.

Pointers are a fundamental concept in low-level programming languages like C and C++. They allow you to directly manipulate memory, which can lead to more efficient code but also introduces risks if not handled carefully.

int x = 5;
int* ptr = &x; // ptr points to the memory address of x

printf("Value of x: %d\n", x);
printf("Address of x: %p\n", (void*)&x);
printf("Value stored in ptr (address of x): %p\n", (void*)ptr);
printf("Value pointed to by ptr: %d\n", *ptr);

What Is Memory Management?​

Memory management refers to how a program allocates, uses, and frees up memory. In low-level languages, you’re responsible for:

  • Allocating memory (e.g., using malloc() in C)
  • Using it carefully (e.g., avoiding out-of-bounds access)
  • Freeing it when you’re done (e.g., using free() in C)

Rust makes this safer by enforcing strict rules about who “owns” each piece of memory and when it gets cleaned up. Go simplifies things with garbage collection but still lets you care about performance and data layout.

Why Does This Matter?​

Most web or mobile developers won’t touch raw pointers often. But understanding them will help you:

  • Debug memory-related bugs (e.g., segmentation faults, leaks)
  • Understand performance tradeoffs in your code
  • Contribute to performance-critical or embedded projects
  • Think more deeply about how data is stored and moved around

Even if you never use C or Rust in your day job, learning them is like weight training for your brain. It’ll make you sharper and more confident across the board.

Knowledge Checklist​

  • I understand what a pointer is and how to use one in C or C++.
  • I’ve written code that allocates and frees memory manually.
  • I know what a segmentation fault is and how to debug one.
  • I understand what a memory leak is and how to prevent it.
  • I understand how Rust uses ownership and borrowing to manage memory safely.
  • I understand the difference between stack and heap memory.
  • I’ve used at least one low-level or memory-conscious language (C, C++, Go, Rust).