{"id":1321,"date":"2023-09-10T20:25:55","date_gmt":"2023-09-10T20:25:55","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=1321"},"modified":"2023-09-10T20:26:00","modified_gmt":"2023-09-10T20:26:00","slug":"cpp-std-vector-from-basics-to-advanced","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/","title":{"rendered":"C++ std::vector: From Basics to Advanced"},"content":{"rendered":"\n

Introduction<\/h2>\n\n\n\n

std::vector<\/code> stands as one of the linchpins of the C++ Standard Library, offering both novices and experienced developers a dynamic array with the ability to automatically manage its size. At its core, std::vector<\/code> provides a way to store elements, typically of the same type, in a contiguous block of memory. Unlike standard arrays in C++, where the size is determined at compile-time, the std::vector<\/code>‘s size can change during runtime, allowing for an adaptive and flexible data structure.<\/p>\n\n\n\n

Brief overview of std::vector<\/code><\/h3>\n\n\n\n

Imagine wanting the convenience of an array but without being shackled by its size limitations. This is where the std::vector<\/code> shines. Unlike arrays, where the size is set during its declaration, vectors are dynamic. You can add or remove elements, and the vector will automatically adjust its size. This does not mean that vectors lack the benefits of arrays. In fact, vectors store their elements in contiguous memory locations, ensuring that array-style random access (using an index) is just as fast and convenient.<\/p>\n\n\n\n

Behind the scenes, std::vector<\/code> handles a lot of heavy lifting. It manages memory allocation and deallocation, ensuring efficient use of resources. When the existing capacity is exhausted and a new element is added, the vector reallocates its memory, usually doubling its current capacity, to accommodate the new elements. This intelligent memory management ensures that operations on a vector, like adding elements, are efficient in average-case scenarios.<\/p>\n\n\n\n

Importance in C++ standard library<\/h3>\n\n\n\n

std::vector<\/code> is more than just a dynamic array; it’s a testament to the philosophy of C++ \u2013 granting power and flexibility without sacrificing performance. When C++ developers, especially those coming from a background in C, need a dynamic list, their go-to choice is often std::vector<\/code>. This is not without reason:<\/p>\n\n\n\n

    \n
  1. Performance<\/strong>: With data stored in contiguous memory, cache locality is improved, which significantly boosts the performance in many scenarios. Iterating over a std::vector<\/code> is usually faster than other containers like std::list<\/code> or std::deque<\/code> due to this.<\/li>\n\n\n\n
  2. Flexibility<\/strong>: The ability to resize, coupled with a rich set of member functions, makes it adaptable to a myriad of problems.<\/li>\n\n\n\n
  3. Memory Efficiency<\/strong>: While std::vector<\/code> manages dynamic memory, it does so efficiently. Functions like reserve()<\/code> and shrink_to_fit()<\/code> give developers fine control over memory usage.<\/li>\n\n\n\n
  4. Integration with C Arrays<\/strong>: Since the elements of a std::vector<\/code> are stored in contiguous memory, it’s straightforward to integrate them with legacy C code by using the data()<\/code> member function.<\/li>\n\n\n\n
  5. Safety with RAII<\/strong>: Resource Acquisition Is Initialization (RAII) is a cornerstone of C++ programming. std::vector<\/code>, like other C++ containers, follows this principle, ensuring that resources (like memory) are automatically managed, reducing chances of leaks or dangling references.<\/li>\n<\/ol>\n\n\n\n

    In the grand tapestry of the C++ Standard Library, std::vector<\/code> is emblematic of what modern C++ offers \u2013 a blending of performance, adaptability, and safety.<\/p>\n\n\n\n

    Preliminaries<\/h2>\n\n\n\n

    Before diving into the depths of std::vector<\/code> and its functionalities, it’s crucial to set up our C++ environment correctly. Like any tool, the power of std::vector<\/code> can only be unlocked if we integrate it properly into our codebase.<\/p>\n\n\n\n

    Header inclusion: #include <vector><\/code><\/h3>\n\n\n\n

    The very first step to utilize std::vector<\/code> is to include its corresponding header file. Just as we include <iostream><\/code> for input-output operations or <algorithm><\/code> for a set of algorithmic functions, to bring the functionalities of std::vector<\/code> into our code, we need:<\/p>\n\n\n

    #include<\/span> <vector><\/span><\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    By adding this line at the beginning of our source code (usually after other standard library headers), we make all the member functions and capabilities of std::vector<\/code> accessible.<\/p>\n\n\n\n
    Namespace consideration: using namespace std;<\/code><\/h3>\n\n\n\n
    C++ namespaces are a way to encapsulate identifier names to avoid naming collisions. The C++ Standard Library places most of its identifiers, including std::vector<\/code>, inside the std<\/code> namespace.<\/p>\n\n\n\n
    When using std::vector<\/code> or any other standard library components, we have two main options:<\/p>\n\n\n\n
    Explicit Namespace Usage<\/strong>: Every time we refer to vector<\/code> or any other standard library entity, we prefix it with the std::<\/code> qualifier.<\/p>\n\n\n
    std<\/span>::vector<\/span><int<\/span>> myVector;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    Using Directive<\/strong>: By writing using namespace std;<\/code> after our includes, we inform the compiler that we want to use everything inside the std<\/code> namespace without the std::<\/code> prefix.<\/p>\n\n\n
    using<\/span> namespace<\/span> std<\/span>;\r\nvector<\/span><int<\/span>> myVector;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    However, it’s essential to be cautious with the using namespace<\/code> directive, especially in header files or large projects. Pulling everything from a namespace, especially one as expansive as std<\/code>, can lead to naming collisions and unexpected behavior. A safer, albeit more verbose, method is to use the std::<\/code> qualifier explicitly or employ using declarations for specific entities:<\/p>\n\n\n
    using<\/span> std<\/span>::vector<\/span>;\r\nvector<\/span><int<\/span>> myVector;  \/\/ Now this works without pulling in the entire `std` namespace.<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    Deep Dive into std::vector<\/code>‘s Anatomy<\/h2>\n\n\n\n
    The true strength of any data structure lies beneath its interface. Understanding the inner workings, the “anatomy” if you will, is key to exploiting its full potential. The std::vector<\/code> is no exception. Let’s unpack the internal details of std::vector<\/code> and see what makes it such a powerful and versatile tool.<\/p>\n\n\n\n
    Memory Layout: Dynamic Array, Contiguous Memory<\/h3>\n\n\n\n
    At its heart, std::vector<\/code> is a dynamic array. But what does that mean?<\/p>\n\n\n\n
      \n
    1. Dynamic Nature<\/strong>: Unlike traditional arrays that have a fixed size once declared, the size of a std::vector<\/code> can change during runtime. It achieves this dynamic resizing through memory allocations and deallocations. When you insert an element into a vector that’s already at its capacity, the vector will allocate a new, larger block of memory, move the existing elements to this new block, and then deallocate the old memory block.<\/li>\n\n\n\n
    2. Contiguous Memory<\/strong>: Despite its dynamic nature, std::vector<\/code> ensures that its elements are stored in a contiguous block of memory, just like a traditional array. This contiguous layout is critical for several reasons:\n
        \n
      • Performance<\/strong>: Contiguous memory ensures that elements are cache-friendly, meaning that when one element is loaded into the CPU cache, its neighbors are likely loaded too, making iterations faster.<\/li>\n\n\n\n
      • Direct Access<\/strong>: Just like arrays, the contiguous memory layout allows for direct access using an index, giving O(1) access time for any element.<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n\n\n\n
        Benefits Over Traditional Arrays<\/h3>\n\n\n\n
        Given its dynamic array nature, std::vector<\/code> offers several advantages over traditional arrays:<\/p>\n\n\n\n
          \n
        1. Dynamic Resizing<\/strong>: As previously mentioned, a std::vector<\/code> resizes itself as needed. This eliminates the guesswork and potential wastage associated with pre-defining an array size.<\/li>\n\n\n\n
        2. Safety Features<\/strong>: std::vector<\/code> provides member functions like at()<\/code>, which can check bounds and throw exceptions if an out-of-bounds access is attempted, offering an extra layer of safety over raw array access.<\/li>\n\n\n\n
        3. Rich Standard Library Integration<\/strong>: Being a part of the C++ Standard Library, std::vector<\/code> comes integrated with a plethora of functions. Whether it’s sorting with std::sort()<\/code> or searching with std::find()<\/code>, vectors play well with the rest of the library, reducing the amount of boilerplate code you have to write.<\/li>\n\n\n\n
        4. Memory Management<\/strong>: While arrays demand manual memory management when dynamically allocated (using pointers and new<\/code>\/delete<\/code>), std::vector<\/code> handles this automatically, reducing the risks of memory leaks or access to deallocated memory.<\/li>\n\n\n\n
        5. Insertions and Deletions<\/strong>: Inserting or removing elements in the middle of an array is cumbersome, requiring shifting of elements manually. In contrast, std::vector<\/code> provides functions like insert()<\/code> and erase()<\/code> to manage this, simplifying code and reducing potential errors.<\/li>\n\n\n\n
        6. Flexibility with Data Types<\/strong>: Vectors can easily store complex data types, including user-defined objects, without the need for intricate pointer arithmetic or memory management.<\/li>\n\n\n\n
        7. RAII Principles<\/strong>: std::vector<\/code>, like many C++ Standard Library containers, adheres to the RAII (Resource Acquisition Is Initialization) principle. This ensures that its memory gets deallocated when it goes out of scope, providing a deterministic behavior and reducing memory management errors.<\/li>\n<\/ol>\n\n\n\n
          std::vector<\/code> combines the best aspects of arrays \u2014 speed, direct access, and cache-friendliness \u2014 with the power and flexibility of dynamic data structures. It abstracts away the challenges and pitfalls of manual memory management, allowing developers to focus on implementing logic and algorithms rather than being bogged down with low-level details.<\/p>\n\n\n\n
          Creating and Initializing std::vector<\/code><\/h2>\n\n\n\n
          The versatility of std::vector<\/code> is further manifested in the multitude of ways it can be initialized. Whether you start with an empty vector or one that’s pre-filled with data, there’s a method tailored to your needs. Let’s explore these methods with practical examples.<\/p>\n\n\n\n
          Default Initialization<\/h3>\n\n\n\n
          This creates an empty vector.<\/p>\n\n\n
          std<\/span>::vector<\/span><int<\/span>> vec1;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Initialization with Size<\/h3>\n\n\n\n
          This initializes the vector with a given size. All elements will have default values (which is 0 for fundamental data types like int<\/code>).<\/p>\n\n\n
          std<\/span>::vector<\/span><int<\/span>> vec2<\/span>(5<\/span>)<\/span><\/span>;  \/\/ Creates a vector of size 5 with all elements as 0<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Initialization with Size and Default Value<\/h3>\n\n\n\n
          This initializes the vector with a given size, and all elements will have a specified default value.<\/p>\n\n\n
          std::vector<int> vec3(5<\/span>, 42<\/span>);  \/\/ Creates a vector of size 5 with all elements as 42<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
          List Initialization<\/h3>\n\n\n\n
          Introduced with C++11, list initialization (also known as uniform initialization) allows you to create a vector and initialize it with specific values.<\/p>\n\n\n
          std<\/span>::vector<\/span><int<\/span>> vec4 = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};  \/\/ Vector with 5 elements: 1, 2, 3, 4, 5<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Alternatively, you can also use:<\/p>\n\n\n
          std<\/span>::vector<\/span><int<\/span>> vec4{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Initialization from Another Vector<\/h3>\n\n\n\n
          A vector can be initialized from another vector. This creates a new vector with the same elements as the original.<\/p>\n\n\n
          std<\/span>::vector<\/span><int<\/span>> vec5 = vec4;  \/\/ Creates a vector with elements 1, 2, 3, 4, 5<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Using std::vector::assign()<\/code><\/h3>\n\n\n\n
          The assign()<\/code> method allows for multiple ways to initialize a vector:<\/p>\n\n\n\n
            \n
          • Using a size and default value:<\/li>\n<\/ul>\n\n\n
            std<\/span>::vector<\/span><int<\/span>> vec6;\r\nvec6.assign(5<\/span>, 10<\/span>);  \/\/ Initializes vec6 with 5 elements, all set to 10<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
              \n
            • From another vector:<\/li>\n<\/ul>\n\n\n
              std<\/span>::vector<\/span><int<\/span>> vec7;\r\nvec7.assign(vec4.begin(), vec4.end());  \/\/ Initializes vec7 with the same elements as vec4<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                \n
              • Using list initialization:<\/li>\n<\/ul>\n\n\n
                std<\/span>::vector<\/span><int<\/span>> vec8;\r\nvec8.assign({10<\/span>, 20<\/span>, 30<\/span>, 40<\/span>, 50<\/span>});  \/\/ Initializes vec8 with elements 10, 20, 30, 40, 50<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                Accessing Elements in std::vector<\/code><\/h2>\n\n\n\n
                One of the primary uses of a vector (or any container) is accessing its elements. std::vector<\/code> provides several ways to achieve this, each with its benefits and considerations.<\/p>\n\n\n\n
                Using operator[]<\/code><\/h3>\n\n\n\n
                This is the most straightforward way to access elements in a vector. It provides direct access similar to arrays.<\/p>\n\n\n
                std<\/span>::vector<\/span><int<\/span>> vec = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\r\nint<\/span> value = vec[2<\/span>];  \/\/ value will be 3<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                Performance Considerations<\/strong>:<\/p>\n\n\n\n
                  \n
                • operator[]<\/code> is very fast and offers O(1) access time.<\/li>\n\n\n\n
                • However, it doesn’t check for out-of-bounds errors. If you access an index that’s outside the vector’s size, it leads to undefined behavior.<\/li>\n<\/ul>\n\n\n\n
                  Using at()<\/code><\/h3>\n\n\n\n
                  The at()<\/code> member function provides a safer way to access elements by checking the provided index against the vector’s size.<\/p>\n\n\n
                  int<\/span> value = vec.at(2<\/span>);  \/\/ value will be 3<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Performance Considerations<\/strong>:<\/p>\n\n\n\n
                    \n
                  • at()<\/code> is slightly slower than operator[]<\/code> because of the boundary check.<\/li>\n\n\n\n
                  • If an out-of-bounds index is provided, it throws an std::out_of_range<\/code> exception.<\/li>\n<\/ul>\n\n\n\n
                    front()<\/code> and back()<\/code><\/h3>\n\n\n\n
                    These member functions provide direct access to the first and last elements of the vector, respectively.<\/p>\n\n\n
                    int<\/span> first = vec.front();  \/\/ first will be 1<\/span>\r\nint<\/span> last = vec.back();    \/\/ last will be 5<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Performance Considerations<\/strong>:<\/p>\n\n\n\n
                      \n
                    • Both front()<\/code> and back()<\/code> are O(1) operations.<\/li>\n\n\n\n
                    • They do not have boundary checks. If the vector is empty and these functions are used, the behavior is undefined.<\/li>\n<\/ul>\n\n\n\n
                      Using Iterators<\/h3>\n\n\n\n
                      Iterators are powerful tools in C++ that allow generic access to elements in a container. They work with vectors just as they do with other containers.<\/p>\n\n\n
                      std<\/span>::vector<\/span><int<\/span>>::iterator it = vec.begin();\r\nint<\/span> firstValue = *it;  \/\/ Dereferencing the iterator gives the value, in this case, 1<\/span>\r\n\r\n\/\/ Iterating through the vector using iterators<\/span>\r\nfor<\/span> (std<\/span>::vector<\/span><int<\/span>>::iterator itr = vec.begin(); itr != vec.end(); ++itr) {\r\n    std<\/span>::cout<\/span> << *itr << \" \"<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                      For C++11 and above, you can use the auto keyword for a more concise syntax:<\/p>\n\n\n
                      for<\/span> (auto<\/span> itr = vec.begin(); itr != vec.end(); ++itr) {\r\n    std<\/span>::cout<\/span> << *itr << \" \"<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                      And with C++11’s range-based for loops, the process is even more streamlined:<\/p>\n\n\n
                      for<\/span> (const<\/span> auto<\/span>& value : vec) {\r\n    std<\/span>::cout<\/span> << value << \" \"<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Performance Considerations<\/strong>:<\/p>\n\n\n\n
                        \n
                      • Iterators provide O(1) access to individual elements.<\/li>\n\n\n\n
                      • Iterating through the entire vector using iterators is an O(n) operation.<\/li>\n\n\n\n
                      • Iterators can become invalidated after certain operations on the vector, like insert<\/code> or erase<\/code>, so always ensure your iterators are valid before use.<\/li>\n<\/ul>\n\n\n\n
                        Modifying std::vector<\/code><\/h2>\n\n\n\n
                        As dynamic containers, vectors in C++ are designed to grow and shrink, offering several member functions to modify their content. Let’s explore some of these functionalities.<\/p>\n\n\n\n
                        push_back()<\/code> & pop_back()<\/code><\/h3>\n\n\n\n
                        push_back()<\/code> adds an element to the end of the vector, while pop_back()<\/code> removes the last element.<\/p>\n\n\n
                        std<\/span>::vector<\/span><int<\/span>> vec = {1<\/span>, 2<\/span>, 3<\/span>};\r\n\r\nvec.push_back(4<\/span>);    \/\/ vec: 1, 2, 3, 4<\/span>\r\nvec.pop_back();      \/\/ vec: 1, 2, 3<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                        insert()<\/code><\/h3>\n\n\n\n
                        This function allows adding elements in the middle of the vector.<\/p>\n\n\n\n
                          \n
                        • At a specific position<\/strong>:<\/li>\n<\/ul>\n\n\n
                          auto<\/span> it = vec.begin() + 1<\/span>;\r\nvec.insert(it, 42<\/span>);  \/\/ Insert 42 at the second position; vec: 1, 42, 2, 3<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                            \n
                          • Inserting n<\/code> elements<\/strong>:<\/li>\n<\/ul>\n\n\n
                            vec.insert(it, 3<\/span>, 42<\/span>);  \/\/ Insert three 42s at the second position; vec: 1, 42, 42, 42, 2, 3<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                              \n
                            • From another vector<\/strong>:<\/li>\n<\/ul>\n\n\n
                              std<\/span>::vector<\/span><int<\/span>> vec2 = {7<\/span>, 8<\/span>, 9<\/span>};\r\nvec.insert(vec.end(), vec2.begin(), vec2.end());  \/\/ Append vec2 to vec; vec: 1, 2, 3, 7, 8, 9<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                              erase()<\/code><\/h3>\n\n\n\n
                              This function removes elements from the vector.<\/p>\n\n\n\n
                                \n
                              • Erase a single element<\/strong>:<\/li>\n<\/ul>\n\n\n
                                auto<\/span> it = vec.begin() + 2<\/span>;\r\nvec.erase(it);  \/\/ Removes the third element; assuming vec: 1, 2, 3, results in vec: 1, 2<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  \n
                                • Erase a range of elements<\/strong>:<\/li>\n<\/ul>\n\n\n
                                  vec.erase(vec.begin() + 1<\/span>, vec.begin() + 3<\/span>);  \/\/ Erase the second and third elements<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  resize()<\/code> and its implications<\/h3>\n\n\n\n
                                  resize()<\/code> changes the size of the vector. If it’s resized to a larger size, new elements are added, and if resized to a smaller size, elements are removed.<\/p>\n\n\n
                                  vec.resize(5<\/span>);    \/\/ Increases size to 5; new elements are default-initialized<\/span>\r\nvec.resize(3<\/span>);    \/\/ Decreases size to 3; last two elements are removed<\/span>\r\nvec.resize(5<\/span>, 42<\/span>);  \/\/ Increases size to 5; new elements are initialized with value 42<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                  Implications<\/strong>:<\/p>\n\n\n\n
                                    \n
                                  • Resizing can trigger reallocations, which means iterators, references, and pointers to the elements might become invalidated.<\/li>\n\n\n\n
                                  • It can be used to quickly remove or add multiple elements.<\/li>\n<\/ul>\n\n\n\n
                                    swap()<\/code> with another vector<\/h3>\n\n\n\n
                                    swap()<\/code> exchanges the content of the vector with that of another vector.<\/p>\n\n\n
                                    std<\/span>::vector<\/span><int<\/span>> vec1 = {1<\/span>, 2<\/span>, 3<\/span>};\r\nstd<\/span>::vector<\/span><int<\/span>> vec2 = {4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>};\r\n\r\nvec1.swap(vec2);  \/\/ vec1: 4, 5, 6, 7 and vec2: 1, 2, 3<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    Note<\/strong>: swap()<\/code> is a very efficient operation, regardless of the vector sizes, as it doesn’t perform a deep copy, but rather exchanges internal pointers.<\/p>\n\n\n\n
                                    Vector Capacity and Management<\/h2>\n\n\n\n
                                    When working with std::vector<\/code>, it’s crucial to understand the distinction between its size and its capacity, as well as how the container manages its underlying memory. Let’s dive into these concepts and their real-world performance implications.<\/p>\n\n\n\n
                                    Understanding Capacity vs. Size<\/h3>\n\n\n\n
                                    Size<\/strong>: This is the number of elements that the vector currently holds.<\/p>\n\n\n
                                    std<\/span>::vector<\/span><int<\/span>> vec = {1<\/span>, 2<\/span>, 3<\/span>};\r\nstd<\/span>::cout<\/span> << vec.size();  \/\/ Outputs: 3<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    Capacity<\/strong>: Represents the amount of storage space that the vector has allocated, which might be greater than the space the actual elements consume. This additional space reduces the number of memory reallocations when new elements are added to the vector.<\/p>\n\n\n
                                    std<\/span>::cout<\/span> << vec.capacity();  \/\/ Outputs a value >= 3<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    reserve()<\/code> and its Use Cases<\/h3>\n\n\n\n
                                    reserve()<\/code> is a function that allows you to request a change in the capacity of the vector. If the passed argument is greater than the current capacity, the function reallocates memory to meet the request. Otherwise, it does nothing.<\/p>\n\n\n
                                    vec.reserve(10<\/span>);  \/\/ Ensure vec has enough memory allocated to hold 10 elements without reallocating<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    Use Cases:<\/h4>\n\n\n\n
                                    Performance Optimization<\/strong>: If you know beforehand how many elements will be inserted into a vector (e.g., in a loop), calling reserve()<\/code> once can prevent multiple reallocations, thus enhancing performance.<\/p>\n\n\n
                                    std<\/span>::vector<\/span><int<\/span>> values;\r\nvalues.reserve(1000<\/span>);\r\nfor<\/span> (int<\/span> i = 0<\/span>; i < 1000<\/span>; ++i) {\r\n    values.push_back(i);\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    In the above code, despite adding 1000 elements, the vector reallocates its memory only once.<\/p>\n\n\n\n
                                    Avoiding Iterator Invalidation<\/strong>: Reallocation might invalidate iterators. By using reserve()<\/code>, you can ensure no reallocation occurs, preserving the validity of iterators.<\/p>\n\n\n\n
                                    shrink_to_fit()<\/code><\/h3>\n\n\n\n
                                    This member function requests the vector to reduce its capacity to fit its size, potentially freeing up memory.<\/p>\n\n\n
                                    vec.shrink_to_fit();<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    Note that while this can save memory, it may involve a memory reallocation, and thus can invalidate iterators.<\/p>\n\n\n\n
                                    Real-world Implications on Performance<\/h3>\n\n\n\n
                                    Understanding the dynamics between size and capacity is crucial for performance-critical applications.<\/p>\n\n\n\n
                                    Unnecessary Reallocations<\/strong>: Without using reserve()<\/code>, adding many elements to a vector can cause multiple reallocations, each potentially copying all elements to a new memory location. This can drastically slow down your program.<\/p>\n\n\n
                                    \/\/ Slower due to potential multiple reallocations<\/span>\r\nstd<\/span>::vector<\/span><int<\/span>> slowVec;\r\nfor<\/span> (int<\/span> i = 0<\/span>; i < 1000<\/span>; ++i) {\r\n    slowVec.push_back(i);\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    Memory Overhead<\/strong>: Over-reserving can lead to wasted memory, as you’re holding onto memory you aren’t using.<\/p>\n\n\n\n
                                    Frequent Shrinking<\/strong>: While shrink_to_fit()<\/code> can be used to optimize memory usage, using it frequently can also introduce performance penalties due to reallocations.<\/p>\n\n\n\n
                                    Iterating through std::vector<\/code><\/h2>\n\n\n\n
                                    One of the most common operations on std::vector<\/code> (or any container) is iterating over its elements. There are various methods to achieve this, each having its own merits.<\/p>\n\n\n\n
                                    Traditional Indexed Loop<\/h3>\n\n\n\n
                                    The classic way, treating std::vector<\/code> like an array and accessing elements using their index.<\/p>\n\n\n
                                    std<\/span>::vector<\/span><int<\/span>> vec = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\r\nfor<\/span> (size_t<\/span> i = 0<\/span>; i < vec.size(); ++i) {\r\n    std<\/span>::cout<\/span> << vec[i] << \" \"<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    Using Iterators<\/h3>\n\n\n\n
                                    Iterators provide a powerful and generic way to access and manipulate elements in a container.<\/p>\n\n\n\n
                                      \n
                                    • Using begin()<\/code> and end()<\/code><\/strong>:<\/li>\n<\/ul>\n\n\n
                                      for<\/span> (std<\/span>::vector<\/span><int<\/span>>::iterator it = vec.begin(); it != vec.end(); ++it) {\r\n    std<\/span>::cout<\/span> << *it << \" \"<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        \n
                                      • Using rbegin()<\/code> and rend()<\/code> for reverse iteration<\/strong>:<\/li>\n<\/ul>\n\n\n
                                        for<\/span> (std<\/span>::vector<\/span><int<\/span>>::reverse_iterator rit = vec.rbegin(); rit != vec.rend(); ++rit) {\r\n    std<\/span>::cout<\/span> << *rit << \" \"<\/span>;  \/\/ Outputs elements in reverse order<\/span>\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Using C++11 Range-based For Loop<\/h3>\n\n\n\n
                                        Introduced in C++11, the range-based for loop offers a more concise way to iterate over all elements in a container.<\/p>\n\n\n
                                        for<\/span> (const<\/span> auto<\/span> &value : vec) {\r\n    std<\/span>::cout<\/span> << value << \" \"<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Examples of Common Operations Using Different Iteration Methods:<\/h3>\n\n\n\n
                                        Modify each element<\/strong> (double each value in the vector):<\/p>\n\n\n\n
                                        Using indexed loop:<\/p>\n\n\n
                                        for<\/span> (size_t<\/span> i = 0<\/span>; i < vec.size(); ++i) {\r\n    vec[i] *= 2<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Using iterators:<\/p>\n\n\n
                                        for<\/span> (auto<\/span> it = vec.begin(); it != vec.end(); ++it) {\r\n    *it *= 2<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Using range-based for loop (note the use of reference):<\/p>\n\n\n
                                        for<\/span> (auto<\/span> &value : vec) {\r\n    value *= 2<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Find an element<\/strong> (search for the number 3):<\/p>\n\n\n\n
                                        Using indexed loop:<\/p>\n\n\n
                                        for<\/span> (size_t<\/span> i = 0<\/span>; i < vec.size(); ++i) {\r\n    if<\/span> (vec[i] == 3<\/span>) {\r\n        std<\/span>::cout<\/span> << \"Found at index \"<\/span> << i << std<\/span>::endl<\/span>;\r\n        break<\/span>;\r\n    }\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Using iterators:<\/p>\n\n\n
                                        auto<\/span> it = std<\/span>::find(vec.begin(), vec.end(), 3<\/span>);\r\nif<\/span> (it != vec.end()) {\r\n    std<\/span>::cout<\/span> << \"Found at position \"<\/span> << std<\/span>::distance(vec.begin(), it) << std<\/span>::endl<\/span>;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Using range-based for loop:<\/p>\n\n\n
                                        size_t<\/span> index = 0<\/span>;\r\nfor<\/span> (const<\/span> auto<\/span> &value : vec) {\r\n    if<\/span> (value == 3<\/span>) {\r\n        std<\/span>::cout<\/span> << \"Found at index \"<\/span> << index << std<\/span>::endl<\/span>;\r\n        break<\/span>;\r\n    }\r\n    ++index;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        While all these methods allow you to iterate over the contents of a std::vector<\/code>, the right choice depends on the particular task at hand. The range-based for loop is often favored for its readability, but traditional methods can offer more control in specific scenarios.<\/p>\n\n\n\n
                                        Special Member Functions<\/h2>\n\n\n\n
                                        In C++, the term “special member functions” refers to certain functions that the compiler can provide default implementations for. In the context of std::vector<\/code>, understanding these is crucial to using vectors effectively, especially when it comes to copy and move semantics.<\/p>\n\n\n\n
                                        Constructors and Destructor<\/h3>\n\n\n\n
                                        Default Constructor<\/strong>: Constructs an empty vector.<\/p>\n\n\n
                                        std<\/span>::vector<\/span><int<\/span>> vec1;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Copy Constructor<\/strong>: Constructs a vector with a copy of the contents of another.<\/p>\n\n\n
                                        std<\/span>::vector<\/span><int<\/span>> vec2 = {1<\/span>, 2<\/span>, 3<\/span>};\r\nstd<\/span>::vector<\/span><int<\/span>> vec3<\/span>(vec2)<\/span><\/span>;  \/\/ Copy constructor<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Move Constructor<\/strong>: Moves the contents of another vector to this vector.<\/p>\n\n\n
                                        std<\/span>::vector<\/span><int<\/span>> vec4<\/span>(std<\/span>::move(vec2))<\/span><\/span>;  \/\/ Move constructor<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Note<\/strong>: After the move, vec2<\/code> is in a valid but unspecified state and can still be used.<\/p>\n\n\n\n
                                        Destructor<\/strong>: Cleans up resources (like memory) when the vector goes out of scope or is explicitly destroyed.<\/p>\n\n\n
                                        {\r\n    std<\/span>::vector<\/span><int<\/span>> vec = {1<\/span>, 2<\/span>, 3<\/span>};\r\n}  \/\/ vec's destructor is called automatically here<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Copy and Move Semantics<\/h3>\n\n\n\n
                                        Understanding copy and move semantics is crucial as it determines how vectors handle resources and how they interact with other objects.<\/p>\n\n\n\n
                                        Copy Semantics<\/strong>: It involves creating a new vector that’s a copy of an existing one. All elements from the source vector are copied to the destination vector.<\/p>\n\n\n
                                        std::vector<int> vecA = {4<\/span>, 5<\/span>, 6<\/span>};\r\nstd::vector<int> vecB = vecA;  \/\/ Copy semantics<\/span>\r\n\r\nstd::cout << vecB[0<\/span>];  \/\/ Outputs: 4<\/span>\r\nvecA[0<\/span>] = 99<\/span>;\r\nstd::cout << vecB[0<\/span>];  \/\/ Still outputs: 4 (because vecB is a separate copy)<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Move Semantics<\/strong>: Introduced in C++11, move semantics allows resources owned by one object to be “moved” to another without copying. This is particularly useful for objects like vectors that manage dynamic memory.<\/p>\n\n\n
                                        std<\/span>::vector<\/span><int<\/span>> vecC = {7<\/span>, 8<\/span>, 9<\/span>};\r\nstd<\/span>::vector<\/span><int<\/span>> vecD = std<\/span>::move(vecC);  \/\/ Move semantics<\/span>\r\n\r\nstd<\/span>::cout<\/span> << vecD[0<\/span>];  \/\/ Outputs: 7<\/span>\r\nstd<\/span>::cout<\/span> << vecC.size();  \/\/ Outputs: 0 (or some unspecified value, since vecC has been moved from)<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                        Benefits<\/strong>:<\/p>\n\n\n\n
                                          \n
                                        • Performance<\/strong>: Move operations are usually faster because they transfer ownership of resources rather than copying them.<\/li>\n\n\n\n
                                        • Flexibility<\/strong>: Move semantics allows for the creation of objects that can’t be copied (e.g., std::unique_ptr<\/code>), but can be moved.<\/li>\n<\/ul>\n\n\n\n
                                          Copy\/Move Assignment<\/strong>: Apart from constructors, vectors also support assignment operations.<\/p>\n\n\n
                                          std::vector<int> vecE, vecF;\r\nvecE = vecA;  \/\/ Copy assignment<\/span>\r\nvecF = std::move(vecE);  \/\/ Move assignment<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                                          Advanced Features & Techniques with std::vector<\/code><\/h2>\n\n\n\n
                                          std::vector<\/code> is more than just a dynamic array; it offers several advanced features that can cater to specific needs, particularly in performance-critical scenarios.<\/p>\n\n\n\n
                                          Allocator-aware Container<\/h3>\n\n\n\n
                                          Every std::vector<\/code> is an allocator-aware container, meaning that it uses an allocator object to manage its storage needs. By default, std::vector<\/code> uses the std::allocator<\/code> class, but you can provide your own custom allocator if necessary.<\/p>\n\n\n\n
                                          Using Custom Allocators with std::vector<\/code><\/h3>\n\n\n\n
                                          Sometimes, you might want to have more control over how memory is allocated and deallocated, especially in applications where memory usage patterns are well-understood. This is where custom allocators come in.<\/p>\n\n\n\n
                                          A custom allocator needs to adhere to the Allocator concept defined by the C++ standard. Here’s a very basic example:<\/p>\n\n\n
                                          template<\/span> <class<\/span> T<\/span>>\r\nstruct<\/span> CustomAllocator<\/span> {<\/span>\r\n    typedef<\/span> T value_type;\r\n    T* allocate<\/span>(std<\/span>::size_t<\/span> n)<\/span> <\/span>{\r\n        return<\/span> new<\/span> T[n];\r\n    }\r\n    void<\/span> deallocate<\/span>(T* p, std<\/span>::size_t<\/span> n)<\/span> <\/span>{\r\n        delete<\/span>[] p;\r\n    }\r\n};\r\n\r\nstd<\/span>::vector<\/span><int<\/span>, CustomAllocator<int<\/span>>> vec;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                          In practice, a custom allocator might use memory pools, shared memory, or some other memory management strategy.<\/p>\n\n\n\n
                                          Emplacement: emplace()<\/code> & emplace_back()<\/code><\/h3>\n\n\n\n
                                          Instead of constructing an object and then copying\/moving it into a vector, emplacement constructs the object directly within the vector’s storage. This can provide performance benefits, especially for types that are expensive to copy.<\/p>\n\n\n\n
                                          emplace_back()<\/code><\/strong>: Adds a new element to the end of the vector, constructed in place.<\/p>\n\n\n
                                          std<\/span>::vector<\/span><std<\/span>::pair<int<\/span>, std<\/span>::string<\/span>>> vec;\r\nvec.emplace_back(1<\/span>, \"one\"<\/span>);  \/\/ Constructs a pair inside the vector<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                          emplace()<\/code><\/strong>: Inserts a new element into the vector at a specified position, constructed in place.<\/p>\n\n\n
                                          auto<\/span> it = vec.begin();\r\nvec.emplace(it, 2<\/span>, \"two\"<\/span>);  \/\/ Constructs a pair inside the vector at the beginning<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                          Use Cases and Performance Advantages<\/h3>\n\n\n\n
                                          Avoiding Temporary Objects<\/strong>: Emplacement can avoid the creation of temporary objects which are then moved\/copied into the vector.<\/p>\n\n\n
                                          class<\/span> ExpensiveToCopy<\/span> {<\/span>\r\n    \/\/ ... some data and methods ...<\/span>\r\n};\r\n\r\nstd<\/span>::vector<\/span><ExpensiveToCopy> vec;\r\nvec.emplace_back(\/* constructor arguments *\/<\/span>);<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                          In the above code, the object is constructed directly inside the vector without any temporary object or unnecessary copy\/move operations.<\/p>\n\n\n\n
                                          Using with Custom Objects<\/strong>: Emplacement is particularly beneficial when used with custom classes that have several constructors or require aggregating data from different sources.<\/p>\n\n\n
                                          class<\/span> Person<\/span> {<\/span>\r\npublic<\/span>:\r\n    Person(std<\/span>::string<\/span> name, int<\/span> age) : name(name), age(age) {}\r\n    \/\/ ... other methods ...<\/span>\r\nprivate<\/span>:\r\n    std<\/span>::string<\/span> name;\r\n    int<\/span> age;\r\n};\r\n\r\nstd<\/span>::vector<\/span><Person> people;\r\npeople.emplace_back(\"Alice\"<\/span>, 30<\/span>);<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                          Performance<\/strong>: Especially for larger objects or containers with many elements, using emplace can be faster than using push or insert, as it can avoid unnecessary temporary objects and copy\/move operations.<\/p>\n\n\n\n
                                          std::vector<\/code> in Concurrency<\/h2>\n\n\n\n
                                          Concurrency in C++ introduces a set of challenges that developers need to be aware of, and when it comes to using std::vector<\/code>, special attention must be paid to ensure safe and correct behavior.<\/p>\n\n\n\n
                                          Thread-safety Considerations<\/h3>\n\n\n\n
                                            \n
                                          • Reads Are Safe<\/strong>: Multiple threads can read elements from a std::vector<\/code> simultaneously without any problem.<\/li>\n\n\n\n
                                          • Writes Need Synchronization<\/strong>: If at least one thread modifies a std::vector<\/code>, and any other thread accesses it simultaneously (even if it’s just reading), you must synchronize access to the vector. This is because modifying operations (like push_back()<\/code>, emplace_back()<\/code>, resize()<\/code>, etc.) might reallocate memory, making iterators, pointers, and references to the vector’s elements invalid.<\/li>\n\n\n\n
                                          • No Concurrent Writes<\/strong>: You should not attempt to modify the same std::vector<\/code> from multiple threads concurrently without synchronization, even if they’re writing to different parts of the vector.<\/li>\n<\/ul>\n\n\n\n
                                            Example Scenarios and Solutions<\/h3>\n\n\n\n
                                            Scenario 1<\/strong>: Multiple threads appending to a std::vector<\/code><\/h4>\n\n\n\n
                                            Problem<\/strong>: Without synchronization, threads might trigger simultaneous reallocations or overwrite each other’s data.<\/p>\n\n\n\n
                                            Solution<\/strong>: Use a mutex to ensure exclusive access to the std::vector<\/code>.<\/p>\n\n\n
                                            std<\/span>::vector<\/span><int<\/span>> vec;\r\nstd<\/span>::mutex vecMutex;\r\n\r\nvoid<\/span> appendToVector<\/span>(int<\/span> value)<\/span> <\/span>{\r\n    std<\/span>::lock_guard<std<\/span>::mutex> lock<\/span>(vecMutex)<\/span><\/span>;\r\n    vec.push_back(value);\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                            Scenario 2<\/strong>: Multiple threads reading from and one thread writing to a std::vector<\/code><\/h4>\n\n\n\n
                                            Problem<\/strong>: Even if reads are safe, the write can invalidate the data being read by other threads.<\/p>\n\n\n\n
                                            Solution<\/strong>: Use a shared mutex or reader-writer lock that allows concurrent reads but exclusive writes.<\/p>\n\n\n
                                            std<\/span>::vector<\/span><int<\/span>> vec;\r\nstd<\/span>::shared_mutex vecMutex;\r\n\r\nint<\/span> readFromVector<\/span>(int<\/span> index)<\/span> <\/span>{\r\n    std<\/span>::shared_lock<std<\/span>::shared_mutex> lock<\/span>(vecMutex)<\/span><\/span>;\r\n    return<\/span> vec[index];\r\n}\r\n\r\nvoid<\/span> writeToVector<\/span>(int<\/span> index, int<\/span> value)<\/span> <\/span>{\r\n    std<\/span>::unique_lock<std<\/span>::shared_mutex> lock<\/span>(vecMutex)<\/span><\/span>;\r\n    vec[index] = value;\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                            Scenario 3<\/strong>: Multiple threads reading from a std::vector<\/code> and occasionally updating<\/h4>\n\n\n\n
                                            Problem<\/strong>: Frequent locking and unlocking can become a performance bottleneck.<\/p>\n\n\n\n
                                            Solution<\/strong>: Opt for strategies like “copy-on-write” where you make a copy of the vector, modify the copy, and then atomically swap the pointers. This can be useful if reads are much more frequent than writes and if the vector isn’t too large.<\/p>\n\n\n
                                            std<\/span>::shared_ptr<\/span><std<\/span>::vector<\/span><int<\/span>>> vecPtr = std<\/span>::make_shared<std<\/span>::vector<\/span><int<\/span>>>();\r\n\r\nvoid<\/span> updateVector<\/span>(std<\/span>::vector<\/span><int<\/span>> newData)<\/span> <\/span>{\r\n    auto<\/span> newVec = std<\/span>::make_shared<std<\/span>::vector<\/span><int<\/span>>>(newData);\r\n    std<\/span>::atomic_store(&vecPtr, newVec);\r\n}\r\n\r\nint<\/span> readFromSharedVector<\/span>(int<\/span> index)<\/span> <\/span>{\r\n    auto<\/span> localVecPtr = std<\/span>::atomic_load(&vecPtr);\r\n    return<\/span> (*localVecPtr)[index];\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                            Concurrency requires careful planning and design. With std::vector<\/code> or any other container, understanding the implications of concurrent access is crucial. Always test concurrent code thoroughly to ensure thread safety and correctness.<\/p>\n\n\n\n
                                            Comparison with Other Containers<\/h2>\n\n\n\n
                                            Each container in the C++ Standard Library serves a distinct purpose and is optimized for certain use cases. Let’s compare std::vector<\/code> with std::list<\/code> and std::deque<\/code>.<\/p>\n\n\n\n
                                            std::vector<\/code> vs. std::list<\/code><\/h3>\n\n\n\n
                                              \n
                                            • Memory Layout<\/strong>:\n
                                                \n
                                              • std::vector<\/code>: Uses a dynamic array, provides contiguous memory.<\/li>\n\n\n\n
                                              • std::list<\/code>: Doubly-linked list, non-contiguous memory.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                              • Performance<\/strong>:\n
                                                  \n
                                                • std::vector<\/code>:\n
                                                    \n
                                                  • O(1) for direct access and appending (amortized).<\/li>\n\n\n\n
                                                  • O(n) for insertions\/deletions (except at the end).<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                  • std::list<\/code>:\n
                                                      \n
                                                    • O(1) for insertions\/deletions if iterator to the position is known.<\/li>\n\n\n\n
                                                    • O(n) for direct access and searching.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                    • Memory Overhead<\/strong>:\n
                                                        \n
                                                      • std::vector<\/code>: Generally more memory-efficient due to contiguous layout.<\/li>\n\n\n\n
                                                      • std::list<\/code>: Each element requires overhead for two pointers (previous and next).<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                      • Reallocation<\/strong>:\n
                                                          \n
                                                        • std::vector<\/code>: Requires occasional reallocation as it grows.<\/li>\n\n\n\n
                                                        • std::list<\/code>: No reallocation needed.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                        • Use Cases<\/strong>:\n
                                                            \n
                                                          • Prefer std::vector<\/code> when:\n
                                                              \n
                                                            • Random access is needed.<\/li>\n\n\n\n
                                                            • You’re mostly adding\/removing elements at the end.<\/li>\n\n\n\n
                                                            • Contiguous memory is beneficial (e.g., cache locality).<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                            • Prefer std::list<\/code> when:\n
                                                                \n
                                                              • Frequent insertions\/deletions in the middle are required.<\/li>\n\n\n\n
                                                              • You need stable iterators (i.e., insertions\/deletions don’t invalidate existing iterators).<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                                                                std::vector<\/code> vs. std::deque<\/code><\/h3>\n\n\n\n
                                                                  \n
                                                                • Memory Layout<\/strong>:\n
                                                                    \n
                                                                  • std::vector<\/code>: Contiguous memory.<\/li>\n\n\n\n
                                                                  • std::deque<\/code>: Array of fixed-size blocks; not fully contiguous but offers near-contiguous storage.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                                  • Performance<\/strong>:\n
                                                                      \n
                                                                    • std::vector<\/code>:\n
                                                                        \n
                                                                      • O(1) for direct access and appending (amortized).<\/li>\n\n\n\n
                                                                      • O(n) for inserting\/removing at the beginning.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                                      • std::deque<\/code>:\n
                                                                          \n
                                                                        • O(1) for direct access, appending, and prepending.<\/li>\n\n\n\n
                                                                        • O(n) for insertions\/deletions in the middle (though generally faster than a list in such cases due to better cache locality).<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                                        • Reallocation<\/strong>:\n
                                                                            \n
                                                                          • std::vector<\/code>: Requires reallocation as it grows.<\/li>\n\n\n\n
                                                                          • std::deque<\/code>: Rarely needs reallocation since it can grow in both directions.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                                          • Use Cases<\/strong>:\n
                                                                              \n
                                                                            • Prefer std::vector<\/code> when:\n
                                                                                \n
                                                                              • Contiguous memory is essential.<\/li>\n\n\n\n
                                                                              • You’re mostly dealing with insertions\/removals at the end.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                                              • Prefer std::deque<\/code> when:\n
                                                                                  \n
                                                                                • You need fast insertions\/removals at both the beginning and end.<\/li>\n\n\n\n
                                                                                • You want near-contiguous memory with more flexibility than a vector.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                                                                                  When to Use Which Container:<\/h3>\n\n\n\n
                                                                                    \n
                                                                                  • std::vector<\/code><\/strong>: Default choice for most scenarios due to its cache-friendliness and efficiency.<\/li>\n\n\n\n
                                                                                  • std::list<\/code><\/strong>: When you need constant-time insertions\/removals in the middle or want stable iterators.<\/li>\n\n\n\n
                                                                                  • std::deque<\/code><\/strong>: When you need fast operations on both ends of the container.<\/li>\n<\/ul>\n\n\n\n
                                                                                    It’s worth noting that the best container for a given situation depends not just on these theoretical considerations, but also on the specifics of the problem, data sizes, hardware, and actual observed performance.<\/p>\n\n\n\n
                                                                                    Common Mistakes and Pitfalls with std::vector<\/code><\/h2>\n\n\n\n
                                                                                    The versatile nature of std::vector<\/code> makes it a popular choice for many C++ developers. However, with its flexibility comes the possibility of misuse. Let’s discuss some common pitfalls and ways to avoid them.<\/p>\n\n\n\n
                                                                                    Iterator Invalidation Scenarios<\/h3>\n\n\n\n
                                                                                    Problem<\/strong>: Iterators, pointers, and references to a std::vector<\/code> might be invalidated after certain operations, leading to undefined behavior.<\/p>\n\n\n\n
                                                                                    Example<\/strong>:<\/p>\n\n\n
                                                                                    std<\/span>::vector<\/span><int<\/span>> vec = {1<\/span>, 2<\/span>, 3<\/span>};\r\nauto<\/span> it = vec.begin();\r\nvec.push_back(4<\/span>);\r\nstd<\/span>::cout<\/span> << *it;  \/\/ This might lead to undefined behavior.<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                                    Solution<\/strong>: Be cautious after operations that might change the vector’s capacity (push_back<\/code>, emplace_back<\/code>, resize<\/code>, etc.). Re-acquire iterators after such operations.<\/p>\n\n\n\n
                                                                                    Reserving Without Consideration<\/h3>\n\n\n\n
                                                                                    Problem<\/strong>: Over-reserving space when it’s not needed can lead to unnecessary memory consumption.<\/p>\n\n\n\n
                                                                                    Example<\/strong>:<\/p>\n\n\n
                                                                                    std<\/span>::vector<\/span><int<\/span>> vec;\r\nvec.reserve(1000000<\/span>);  \/\/ Reserving space for a million integers when you might only use a few is wasteful.<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                                    Solution<\/strong>: Use reserve<\/code> judiciously. It’s a powerful tool for optimization when you know in advance how many elements you’ll insert, but avoid arbitrary large values.<\/p>\n\n\n\n
                                                                                    Misusing Capacity and Size<\/h3>\n\n\n\n
                                                                                    Problem<\/strong>: Confusing size()<\/code> (number of elements) with capacity()<\/code> (allocated storage) can lead to logical errors.<\/p>\n\n\n\n
                                                                                    Example<\/strong>:<\/p>\n\n\n
                                                                                    std<\/span>::vector<\/span><int<\/span>> vec = {1<\/span>, 2<\/span>, 3<\/span>};\r\nvec.reserve(100<\/span>);\r\nif<\/span> (vec.size() < 100<\/span>) { \r\n    \/\/ This condition is true, but some might expect it to be false due to misunderstanding reserve().<\/span>\r\n    \/\/ ...<\/span>\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                                    Solution<\/strong>: Always remember:<\/p>\n\n\n\n
                                                                                      \n
                                                                                    • size()<\/code>: Current number of elements.<\/li>\n\n\n\n
                                                                                    • capacity()<\/code>: Total storage currently allocated (capacity >= size).<\/li>\n<\/ul>\n\n\n\n
                                                                                      Unintentional Reallocation<\/h3>\n\n\n\n
                                                                                      Problem<\/strong>: Continuously adding elements to a vector without considering its capacity might cause multiple reallocations, potentially degrading performance.<\/p>\n\n\n\n
                                                                                      Example<\/strong>:<\/p>\n\n\n
                                                                                      std<\/span>::vector<\/span><int<\/span>> vec;\r\nfor<\/span> (int<\/span> i = 0<\/span>; i < 1000000<\/span>; ++i) {\r\n    vec.push_back(i);  \/\/ This might cause several reallocations as the vector grows.<\/span>\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                                      Solution<\/strong>: If you know the number of elements or an upper bound beforehand, use reserve()<\/code> to allocate sufficient memory at once.<\/p>\n\n\n\n
                                                                                      Expecting a Vector to Shrink Automatically<\/h3>\n\n\n\n
                                                                                      Problem<\/strong>: Removing elements from a vector decreases its size but not its capacity.<\/p>\n\n\n\n
                                                                                      Example<\/strong>:<\/p>\n\n\n
                                                                                      std<\/span>::vector<\/span><int<\/span>> vec = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\r\nvec.erase(vec.begin(), vec.begin() + 3<\/span>);\r\n\/\/ vec.size() is now 2, but vec.capacity() remains unchanged.<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                                      Solution<\/strong>: If you want to reduce the capacity of a vector to fit its size after removing elements, use shrink_to_fit()<\/code>.<\/p>\n\n\n\n
                                                                                      Optimization Tips for std::vector<\/code><\/h2>\n\n\n\n
                                                                                      A well-optimized use of std::vector<\/code> can result in significantly better performance in your C++ applications. Here are some optimization tips to get the most out of this container:<\/p>\n\n\n\n
                                                                                      Reserving Capacity Wisely<\/h3>\n\n\n\n
                                                                                        \n
                                                                                      • Benefit<\/strong>: Reduces the number of reallocations and potential copy\/move operations.<\/li>\n\n\n\n
                                                                                      • Tip<\/strong>: If you have a good estimate of how many elements you’ll be inserting into the vector, use reserve()<\/code> to pre-allocate memory.<\/li>\n<\/ul>\n\n\n
                                                                                        std<\/span>::vector<\/span><int<\/span>> vec;\r\nvec.reserve(1000<\/span>);  \/\/ Pre-allocate space for 1000 integers<\/span>\r\nfor<\/span> (int<\/span> i = 0<\/span>; i < 1000<\/span>; ++i) {\r\n    vec.push_back(i);\r\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                                        Using shrink_to_fit()<\/code> Appropriately<\/h3>\n\n\n\n
                                                                                          \n
                                                                                        • Benefit<\/strong>: Releases unused capacity, optimizing memory usage.<\/li>\n\n\n\n
                                                                                        • Tip<\/strong>: If you’ve removed a substantial number of elements or if you know that the vector won’t grow much more, consider shrinking its capacity.<\/li>\n<\/ul>\n\n\n
                                                                                          std<\/span>::vector<\/span><int<\/span>> vec = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\r\nvec.erase(vec.begin(), vec.begin() + 3<\/span>);  \/\/ Remove the first 3 elements<\/span>\r\nvec.shrink_to_fit();  \/\/ Reduce the capacity to fit the current size<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                                          Avoiding Frequent Inserts\/Deletions in the Middle<\/h3>\n\n\n\n
                                                                                            \n
                                                                                          • Benefit<\/strong>: Improves performance by avoiding the overhead of shifting elements.<\/li>\n\n\n\n
                                                                                          • Tip<\/strong>: std::vector<\/code> is optimized for fast access and insertions at the end. If you find yourself frequently inserting or removing elements from the middle, consider if another container, like std::list<\/code> or std::deque<\/code>, might be more suitable.<\/li>\n<\/ul>\n\n\n
                                                                                            std<\/span>::vector<\/span><int<\/span>> vec = {1<\/span>, 2<\/span>, 4<\/span>, 5<\/span>};\r\n\/\/ Inserting in the middle requires shifting the subsequent elements<\/span>\r\nvec.insert(vec.begin() + 2<\/span>, 3<\/span>);  \/\/ Expensive operation for large vectors<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                                            Preferring emplace<\/code> Over insert<\/code><\/h3>\n\n\n\n
                                                                                              \n
                                                                                            • Benefit<\/strong>: Constructs elements in-place, avoiding unnecessary copy or move operations.<\/li>\n\n\n\n
                                                                                            • Tip<\/strong>: When inserting objects, use emplace<\/code> or emplace_back<\/code> to construct them directly within the vector.<\/li>\n<\/ul>\n\n\n
                                                                                              struct<\/span> MyClass<\/span> {<\/span>\r\n    MyClass(int<\/span> a, double<\/span> b) : x(a), y(b) {}\r\n    int<\/span> x;\r\n    double<\/span> y;\r\n};\r\n\r\nstd<\/span>::vector<\/span><MyClass> vec;\r\nvec.emplace_back(1<\/span>, 2.5<\/span>);  \/\/ Directly constructs MyClass inside the vector<\/span>\r\n\r\nMyClass obj<\/span>(1<\/span>, 2.5<\/span>)<\/span><\/span>;\r\nvec.insert(vec.end(), obj);  \/\/ Potentially less efficient than emplace_back<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                                              When working with std::vector<\/code> or any container, always be mindful of the specific use-case and its requirements. A careful combination of design decisions and understanding the container’s underlying behavior can yield significant performance gains.<\/p>\n","protected":false},"excerpt":{"rendered":"
                                                                                              Introduction std::vector stands as one of the linchpins of the C++ Standard Library, offering both novices and experienced developers a dynamic array with the ability to automatically manage its size. At its core, std::vector provides a way to store elements, typically of the same type, in a contiguous block of memory. Unlike standard arrays in […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[9,4],"tags":[],"class_list":["post-1321","post","type-post","status-publish","format-standard","category-cplusplus","category-programming-languages","entry"],"yoast_head":"\nC++ std::vector: From Basics to Advanced<\/title>\n<meta name=\"description\" content=\"At its core, std::vector provides a way to store elements, typically of the same type, in a contiguous block of memory. Unlike standard\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"C++ std::vector: From Basics to Advanced\" \/>\n<meta property=\"og:description\" content=\"At its core, std::vector provides a way to store elements, typically of the same type, in a contiguous block of memory. Unlike standard\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-09-10T20:25:55+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-09-10T20:26:00+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"18 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-std-vector-from-basics-to-advanced\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-std-vector-from-basics-to-advanced\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"C++ std::vector: From Basics to Advanced\",\"datePublished\":\"2023-09-10T20:25:55+00:00\",\"dateModified\":\"2023-09-10T20:26:00+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-std-vector-from-basics-to-advanced\\\/\"},\"wordCount\":3960,\"commentCount\":0,\"articleSection\":[\"C++\",\"Programming Languages\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-std-vector-from-basics-to-advanced\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-std-vector-from-basics-to-advanced\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-std-vector-from-basics-to-advanced\\\/\",\"name\":\"C++ std::vector: From Basics to Advanced\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2023-09-10T20:25:55+00:00\",\"dateModified\":\"2023-09-10T20:26:00+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"At its core, std::vector provides a way to store elements, typically of the same type, in a contiguous block of memory. Unlike standard\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-std-vector-from-basics-to-advanced\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-std-vector-from-basics-to-advanced\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/cpp-std-vector-from-basics-to-advanced\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"C++ std::vector: From Basics to Advanced\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"C++ std::vector: From Basics to Advanced","description":"At its core, std::vector provides a way to store elements, typically of the same type, in a contiguous block of memory. Unlike standard","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/","og_locale":"en_US","og_type":"article","og_title":"C++ std::vector: From Basics to Advanced","og_description":"At its core, std::vector provides a way to store elements, typically of the same type, in a contiguous block of memory. Unlike standard","og_url":"https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/","article_published_time":"2023-09-10T20:25:55+00:00","article_modified_time":"2023-09-10T20:26:00+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"18 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"C++ std::vector: From Basics to Advanced","datePublished":"2023-09-10T20:25:55+00:00","dateModified":"2023-09-10T20:26:00+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/"},"wordCount":3960,"commentCount":0,"articleSection":["C++","Programming Languages"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/","url":"https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/","name":"C++ std::vector: From Basics to Advanced","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2023-09-10T20:25:55+00:00","dateModified":"2023-09-10T20:26:00+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"At its core, std::vector provides a way to store elements, typically of the same type, in a contiguous block of memory. Unlike standard","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/cpp-std-vector-from-basics-to-advanced\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"C++ std::vector: From Basics to Advanced"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1321","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=1321"}],"version-history":[{"count":9,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1321\/revisions"}],"predecessor-version":[{"id":1330,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1321\/revisions\/1330"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=1321"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=1321"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=1321"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}