Introduction to Modern C++: Vector and Unique Pointer

Modern C Journey as a Software Developer

If you’re working with C++, there are two fundamental concepts you need to know to write safe and effective code: the vector and the unique pointer. That’s the focus of this post.

Vector: Dynamic Arrays Made Easy

The vector is a dynamic array provided by the C++ standard library. It manages memory allocation and deallocation internally, allowing for growing and shrinking as needed when you add or remove elements. This means you don’t need to worry about manual memory management, reducing the risk of memory leaks and other related issues.

The vector provides several advantages for safe and effective coding:

  • Automatic memory management: the vector handles all memory allocation and deallocation, preventing memory leaks and ensuring that allocated memory is released when the vector goes out of scope. You never allocate or free objects directly; you let the vector do it for you.
  • Bounce checking: the vector provides an at function that helps you prevent buffer overflow and other out-of-bounds access errors. While you don’t have to use it, you can rely on the vector’s built-in bounce checking to catch errors early.
  • Iterator support: the vector supports iterators, making it easier to work with standard library algorithms and ranged-based for loops. You can create a for loop that just iterates over every element in a vector without worrying about indexes and bounds.
  • Dynamic resizing: the vector grows and shrinks as elements are added or removed, without the need for manual sizing.

Unique Pointer: Smart Pointers for Ownership Control

The unique pointer is a smart pointer provided by the C++ standard library that represents unique ownership of a dynamically allocated object. It automatically deletes the object when the unique pointer itself goes out of scope, ensuring that there is only one owner of the allocated memory at any given time. This avoids issues such as double deletion, memory leaks, and dangling pointers.

Using unique pointer provides several advantages:

  • Ownership semantics: unique pointer enforces a clear ownership policy, ensuring that there is only one owner of the allocated memory at any given time.
  • Automatic memory management: unique pointer handles memory allocation and deallocation automatically, releasing the object memory when the unique pointer goes out of scope or is explicitly reset.
  • Custom deleters: unique pointer supports custom deleters, allowing for more fine-grained control over how the managed object is deleted. For example, you can specify a special allocator for external PS RAM and let the relevant classes use it without manually allocating or freeing the memory.
  • Move semantics: unique pointer supports move semantics, allowing for the efficient transfer of ownership without copying the managed object. This leads to much more efficient code.


Using modern C++ features like vector and unique pointer can help you write safe, effective, and maintainable code. It simplifies resource management and makes the code more readable and robust. Additionally, it can help reduce memory problems as it provides better memory management, increased safety, and improved performance.

As you become more comfortable with modern C++, you may want to explore other features like shared pointers, which provide shared ownership of dynamically allocated objects. These pointers can be particularly useful in situations where multiple objects need to reference the same underlying resource.

It’s worth noting that while modern C++ features like vectors and unique pointers can help improve code quality and safety, they are not a substitute for good programming practices. It’s still important to understand the underlying principles of memory management and write clear, well-organized code that is easy to maintain and debug.

In conclusion, learning the basics of modern C++ is an essential step for anyone looking to write effective and efficient code. By leveraging features like vectors and unique pointers, you can simplify resource management and reduce the risk of common memory management issues. With practice and experience, you can become a skilled C++ programmer capable of creating robust, high-performance applications.