C++ Standard Library: Sequential Containers

Non-trivial computer programs need to store data and process it. Developing data structures and containers from scratch in C++ is a daunting and bug-prone task. In fact, you would have to consider advanced aspects like manual memory and resource management, proper handling subtle corner cases, writing both generic code and code that is optimized for special cases, and so on. Thankfully, the C++ Standard Library already offers containers that are high-quality, efficient and well-tested. It's a joy to develop C++ code reusing them: In fact, using these containers in your C++ code, will boost your productivity, as the C++ Standard Library gives you on a platter high-quality implementations of common and useful data structures, that you can easily leverage in your C++ code.

C++ Standard Library's maintainers spend hours looking at these data structures, and improving, refining, and optimizing their C++ implementation code. In this course, you'll learn how to simply reuse that treasure in your own C++ applications.

In particular, you'll learn about std::vector, which is a flexible dynamic array, that should be the default container of choice in many contexts in C++ applications.

You'll enjoy the automatic resource management (for both memory resources and non-memory ones) offered by std::vector, which will help you develop both efficient and safer C++ code.

You'll also see how convenient is for example to grow a vector, still keeping the contiguous memory layout requirement for its elements.

You'll also learn about important operations, like inserting, removing and searching elements, using both C++ container methods and Standard Library's algorithms. In fact, C++ standard containers and algorithms are kind of like “bread and butter”, and you can do great things using both. You don't need to have any previous experience with the C++ Standard Library, as I'll teach you its great and flexible design based on containers, algorithms and iterators, and you'll see how containers are wired with algorithms using iterators, and how you can reuse the same algorithms with different containers.

You'll also learn that in some specific cases you can use a zero-overhead standard container that wraps fixed-size C-style arrays in a convenient high-level safe C++ interface: it's std::array. I'll compare and contrast it against std::vector, and you'll learn pros and cons of each one.

You'll also learn how to use the std::list container, if you need a high-level C++ abstraction based on the doubly-linked list data structure. Moreover, seeing the same algorithms used with different containers will also work very well as a reinforcement learning experience for you.

I'll also show you some subtle bugs, that are especially frequent in those starting learning the C++ Standard Library's containers, and how to fix them. I hope this will save you time and headache during your C++ programming.

To proficiently follow this course, you only need a basic knowledge of C++ language features.

After completing this course, you will be able to use high-quality efficient and well-tested C++ Standard Library containers like std::vector, std::array and std::list in your own C++ code. You'll have practical knowledge about them, and you'll be able to make proper judgement about picking one or the other based on the problem at hand. You'll also have knowledge about important common operations with these standard containers, like inserting, removing and searching items.