{"id":1226,"date":"2023-09-06T12:06:57","date_gmt":"2023-09-06T12:06:57","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=1226"},"modified":"2023-10-02T06:42:54","modified_gmt":"2023-10-02T06:42:54","slug":"c-stdlist-from-basics-to-advanced","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/c-stdlist-from-basics-to-advanced\/","title":{"rendered":"C++ std::list (<list>)- From Basics to Advanced"},"content":{"rendered":"\n

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

What is std::list<\/code>?<\/h3>\n\n\n\n

std::list<\/code> is one of the sequence containers provided by the Standard Template Library (STL) in C++, that allows the storage and manipulation of a doubly-linked list of elements. Each element in the list is stored in a node, and each node contains a pointer to the previous node and the next node in the sequence. This structure grants the std::list<\/code> certain advantages, as well as some limitations.<\/p>\n\n\n\n

Being a part of the STL, std::list<\/code> offers a wide range of member functions that make it easy to insert, delete, and manage elements. One of the most noteworthy attributes of std::list<\/code> is its ability to maintain the order of insertion, allowing for constant-time insertions and deletions from anywhere in the container.<\/p>\n\n\n\n

How does it compare to other C++ containers?<\/h3>\n\n\n\n

To understand where std::list<\/code> stands in the realm of C++ containers, let’s compare it with a couple of other commonly used containers:<\/p>\n\n\n\n

    \n
  1. std::vector<\/code>:<\/strong>\n
      \n
    • Structure:<\/strong> Dynamic array.<\/li>\n\n\n\n
    • Memory Allocation:<\/strong> Elements are stored contiguously in memory.<\/li>\n\n\n\n
    • Insertion\/Deletion:<\/strong> Fast at the end but can be slow in the middle since elements might need to be shifted.<\/li>\n\n\n\n
    • Access:<\/strong> Provides random access, meaning you can access any element directly through an index.<\/li>\n\n\n\n
    • Use Case:<\/strong> When you need dynamic size and random access, and most insertions\/deletions are at the end.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
    • std::deque<\/code>:<\/strong>\n
        \n
      • Structure:<\/strong> Double-ended queue.<\/li>\n\n\n\n
      • Memory Allocation:<\/strong> Non-contiguous blocks of memory.<\/li>\n\n\n\n
      • Insertion\/Deletion:<\/strong> Fast at both the beginning and the end.<\/li>\n\n\n\n
      • Access:<\/strong> Provides random access, but slower compared to std::vector<\/code>.<\/li>\n\n\n\n
      • Use Case:<\/strong> When you need fast insertions\/deletions at both ends and the benefits of random access.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
      • std::list<\/code>:<\/strong>\n
          \n
        • Structure:<\/strong> Doubly-linked list.<\/li>\n\n\n\n
        • Memory Allocation:<\/strong> Non-contiguous. Each element is stored in a node with two pointers (next and previous).<\/li>\n\n\n\n
        • Insertion\/Deletion:<\/strong> Fast anywhere in the list with a known iterator.<\/li>\n\n\n\n
        • Access:<\/strong> Does not provide random access. You must traverse the list sequentially.<\/li>\n\n\n\n
        • Use Case:<\/strong> When you need frequent insertions\/deletions in the middle, and the absence of random access is acceptable.<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n\n\n\n

          The choice between std::list<\/code> and other containers largely depends on the specific requirements of your application. If you need efficient middle insertions and deletions and don’t require direct access to elements by index, std::list<\/code> could be an ideal choice. Otherwise, containers like std::vector<\/code> or std::deque<\/code> might be more suitable.<\/p>\n\n\n\n

          Basic Concepts of std::list<\/code><\/h2>\n\n\n\n

          As we set foot into the domain of C++ containers, it’s essential to grasp the foundational concepts that underpin std::list<\/code>. This section offers a clear understanding of its characteristics, the underlying data structure, and how it contrasts with arrays and vectors in terms of advantages and limitations.<\/p>\n\n\n\n

          Characteristics<\/h3>\n\n\n\n
            \n
          1. Dynamic Size:<\/strong> Unlike arrays, std::list<\/code> can adjust its size dynamically. As you insert or remove elements, it grows or shrinks accordingly.<\/li>\n\n\n\n
          2. Element Ordering:<\/strong> The order in which you insert elements is preserved. This ensures that the elements are always arranged in the sequence they were added.<\/li>\n\n\n\n
          3. Non-contiguous Memory:<\/strong> Unlike arrays or vectors, the elements in a std::list<\/code> are not stored in a continuous block of memory. Each element is stored in its own node.<\/li>\n\n\n\n
          4. Bidirectional Iterators:<\/strong> std::list<\/code> provides bidirectional iterators. This means you can iterate over the elements in both forward and reverse directions. However, it doesn\u2019t support random access iterators, so direct access via an index (like in arrays or vectors) isn’t possible.<\/li>\n<\/ol>\n\n\n\n

            Underlying Data Structure: Doubly-linked list<\/h3>\n\n\n\n

            The backbone of std::list<\/code> is a doubly-linked list. Here’s a brief insight:<\/p>\n\n\n\n

              \n
            1. Nodes:<\/strong> Each element is stored in a node. A node comprises the data (element) and two pointers\u2014one pointing to the previous node and one to the next node.<\/li>\n\n\n\n
            2. Head and Tail:<\/strong> In a typical doubly-linked list, there’s a head (starting node) and a tail (ending node). The head’s previous pointer and the tail’s next pointer are generally null, indicating the start and end of the list, respectively.<\/li>\n\n\n\n
            3. Insertion and Deletion:<\/strong> Thanks to this structure, adding or removing nodes in between is relatively efficient. You just need to adjust the pointers of the neighboring nodes.<\/li>\n<\/ol>\n\n\n\n

              Benefits and Drawbacks over Arrays\/Vectors<\/h3>\n\n\n\n

              Benefits:<\/strong><\/p>\n\n\n\n

                \n
              1. Efficient Insertions\/Deletions:<\/strong> Inserting or deleting an element in the middle of a std::list<\/code> is efficient, as it requires only the adjustment of a few pointers. In contrast, vectors or arrays might need to shift elements, making the operation more time-consuming.<\/li>\n\n\n\n
              2. No Memory Reallocation:<\/strong> Since std::list<\/code> doesn’t use contiguous memory, adding elements doesn’t require reallocation of memory or moving other elements, as can be the case with vectors.<\/li>\n\n\n\n
              3. Fixed Size Overhead Per Element:<\/strong> Each element in a std::list<\/code> has an overhead of two pointers (for next and previous). This overhead is consistent regardless of the list’s size.<\/li>\n<\/ol>\n\n\n\n

                Drawbacks:<\/strong><\/p>\n\n\n\n

                  \n
                1. Memory Usage:<\/strong> Due to the additional storage of two pointers for each element, std::list<\/code> typically uses more memory than a vector or array storing the same data.<\/li>\n\n\n\n
                2. No Random Access:<\/strong> Direct access to an element via an index isn’t possible. To access the nth element, you’d need to traverse n nodes, making certain operations slower than with arrays or vectors.<\/li>\n\n\n\n
                3. Cache Unfriendliness:<\/strong> Since elements aren’t stored contiguously, cache locality is not as optimal as in vectors. This can lead to performance hits due to more frequent cache misses.<\/li>\n<\/ol>\n\n\n\n

                  Getting Started with std::list<\/code><\/h2>\n\n\n\n

                  Once you have your environment set up and have familiarized yourself with the basic concepts, it’s time to dive into the practical implementation. The first and foremost step is to include the necessary header file to utilize std::list<\/code>.<\/p>\n\n\n\n

                  How to include the necessary header<\/h3>\n\n\n\n

                  In C++, header files act as the gateway to various libraries and functionalities. To work with std::list<\/code>, you need to include its specific header.<\/p>\n\n\n\n

                  Here’s how you do it:<\/p>\n\n\n

                  #include<\/span> <list><\/span><\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                  By adding the above line at the beginning of your C++ program, you’re instructing the compiler to include the definitions and functionalities related to std::list<\/code> provided by the Standard Template Library (STL).<\/p>\n\n\n\n
                  Example:<\/h4>\n\n\n\n
                  To provide a simple illustration, here’s a short program that initializes a std::list<\/code> with a few integer values and then prints them:<\/p>\n\n\n
                  #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <list><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    \/\/ Initialize a list with some values<\/span>\n    std<\/span>::list<\/span><int<\/span>> numbers = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\n\n    \/\/ Print the values<\/span>\n    for<\/span> (int<\/span> num : numbers) {\n        std<\/span>::cout<\/span> << num << \" \"<\/span>;\n    }\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                  When you run this program, it will output:<\/p>\n\n\n
                  1 2 3 4 5<\/code><\/span>Code language:<\/span> plaintext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Now, with the header included and a basic understanding of initializing a std::list<\/code>, you’re all set to explore its varied functionalities and operations in subsequent sections.<\/p>\n\n\n\n
                  Creating and Initializing std::list<\/code><\/h2>\n\n\n\n
                  The versatility of std::list<\/code> is also mirrored in the variety of ways you can create and initialize it. Let’s explore some common methods to instantiate lists, providing you with a solid foundation to begin your foray into this useful container.<\/p>\n\n\n\n
                  Default constructor<\/h3>\n\n\n\n
                  Using the default constructor, you can create an empty std::list<\/code>.<\/p>\n\n\n
                  std<\/span>::list<\/span><int<\/span>> emptyList;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Here, emptyList<\/code> is a list of integers that currently holds no values.<\/p>\n\n\n\n
                  Initialization with an array or other containers<\/h3>\n\n\n\n
                  If you have data in other containers (like arrays or vectors), you can initialize a std::list<\/code> using that data.<\/p>\n\n\n\n
                  Array:<\/strong><\/p>\n\n\n
                  int<\/span> arr[] = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\nstd<\/span>::list<\/span><int<\/span>> listFromArray<\/span>(arr, arr + sizeof<\/span>(arr)\/sizeof<\/span>(arr[0<\/span>]))<\/span><\/span>;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Vector:<\/strong><\/p>\n\n\n
                  std<\/span>::vector<\/span><int<\/span>> vec = {6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>, 10<\/span>};\nstd<\/span>::list<\/span><int<\/span>> listFromVector<\/span>(vec.begin(), vec.end())<\/span><\/span>;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Both methods utilize the range constructor of std::list<\/code>, which takes two iterators (beginning and end) of the container to copy the elements.<\/p>\n\n\n\n
                  Initialization with a count and value<\/h3>\n\n\n\n
                  You can also initialize a std::list<\/code> by specifying the count of elements and the value that each of those elements should hold.<\/p>\n\n\n
                  std<\/span>::list<\/span><int<\/span>> tenTwos<\/span>(10<\/span>, 2<\/span>)<\/span><\/span>;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Here, tenTwos<\/code> is a list that contains ten elements, all of which have the value 2<\/code>.<\/p>\n\n\n\n
                  Additional Initialization Methods:<\/h3>\n\n\n\n
                  Initializer List:<\/strong><\/p>\n\n\n\n
                  Just as we’ve seen in previous examples, std::list<\/code> can be initialized using an initializer list.<\/p>\n\n\n
                  std<\/span>::list<\/span><int<\/span>> numbers = {11<\/span>, 12<\/span>, 13<\/span>, 14<\/span>, 15<\/span>};<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Copy Constructor:<\/strong><\/p>\n\n\n\n
                  You can create a new list by copying an existing one.<\/p>\n\n\n
                  std<\/span>::list<\/span><int<\/span>> originalList = {16<\/span>, 17<\/span>, 18<\/span>, 19<\/span>, 20<\/span>};\nstd<\/span>::list<\/span><int<\/span>> copiedList<\/span>(originalList)<\/span><\/span>;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Move Constructor (C++11 and above):<\/strong><\/p>\n\n\n\n
                  If you don’t need the data in the original list after copying, you can use the move constructor to transfer ownership without the overhead of copying.<\/p>\n\n\n
                  std<\/span>::list<\/span><int<\/span>> movedList<\/span>(std<\/span>::move(originalList))<\/span><\/span>;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Accessing Elements in std::list<\/code><\/h2>\n\n\n\n
                  Unlike arrays or vectors, std::list<\/code> does not provide random access to its elements due to its non-contiguous nature. However, there are still several ways to access its elements, and understanding these methods is crucial for effective utilization of the list.<\/p>\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 list, respectively.<\/p>\n\n\n\n
                  Example:<\/strong><\/p>\n\n\n
                  std<\/span>::list<\/span><int<\/span>> numbers = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\n\nint<\/span> firstElement = numbers.front(); \/\/ firstElement gets the value 1<\/span>\nint<\/span> lastElement = numbers.back();  \/\/ lastElement gets the value 5<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                  Iterators and their Importance<\/h3>\n\n\n\n
                  Iterators are fundamental to std::list<\/code> and many other STL containers. They act like pointers, pointing to elements within the container, and allow for sequential access to those elements.<\/p>\n\n\n\n
                  Why are Iterators Important?<\/strong><\/p>\n\n\n\n
                    \n
                  • Sequential Access:<\/strong> As mentioned, std::list<\/code> doesn’t support direct indexing, so iterators provide a way to traverse and access elements sequentially.<\/li>\n\n\n\n
                  • Generic Algorithms:<\/strong> STL provides a set of algorithms (like std::find<\/code>, std::sort<\/code>, etc.) that work on different containers. These algorithms use iterators to work seamlessly across diverse containers.<\/li>\n\n\n\n
                  • Manipulation:<\/strong> Iterators are essential when you want to insert or erase elements at specific positions within a std::list<\/code>.<\/li>\n<\/ul>\n\n\n\n
                    Basic Usage:<\/strong><\/p>\n\n\n
                    std<\/span>::list<\/span><int<\/span>> numbers = {10<\/span>, 20<\/span>, 30<\/span>, 40<\/span>, 50<\/span>};\n\n\/\/ Obtain iterators to the beginning and end of the list<\/span>\nstd<\/span>::list<\/span><int<\/span>>::iterator beginIter = numbers.begin();\nstd<\/span>::list<\/span><int<\/span>>::iterator endIter = numbers.end();\n\n\/\/ Use the iterators to traverse and print the list<\/span>\nfor<\/span> (std<\/span>::list<\/span><int<\/span>>::iterator it = beginIter; it != endIter; ++it) {\n    std<\/span>::cout<\/span> << *it << \" \"<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    The above code will output:Copy code<\/p>\n\n\n
                    10 20 30 40 50<\/code><\/span>Code language:<\/span> plaintext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Range-based For Loop (C++11 and above):<\/strong><\/p>\n\n\n\n
                    C++11 introduced range-based for loops, which provide a more concise way to iterate over containers. Here’s how you can use it with std::list<\/code>:<\/p>\n\n\n
                    for<\/span> (int<\/span> num : numbers) {\n    std<\/span>::cout<\/span> << num << \" \"<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Reverse Iteration:<\/strong><\/p>\n\n\n\n
                    std::list<\/code> provides bidirectional iterators, which means you can also traverse the list in reverse:<\/p>\n\n\n
                    for<\/span> (std<\/span>::list<\/span><int<\/span>>::reverse_iterator rit = numbers.rbegin(); rit != numbers.rend(); ++rit) {\n    std<\/span>::cout<\/span> << *rit << \" \"<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    This will output:Copy code<\/p>\n\n\n
                    50<\/span> 40<\/span> 30<\/span> 20<\/span> 10<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Manipulating std::list<\/code><\/h2>\n\n\n\n
                    Understanding how to manipulate the elements of std::list<\/code> is essential for effectively using the container. Below, we explore the various operations available to add, remove, and modify the elements of a std::list<\/code>.<\/p>\n\n\n\n
                    Inserting Elements<\/h3>\n\n\n\n
                    push_front()<\/code><\/strong>: Adds an element to the beginning of the list.<\/p>\n\n\n
                    std<\/span>::list<\/span><int<\/span>> numbers = {2<\/span>, 3<\/span>, 4<\/span>};\nnumbers.push_front(1<\/span>);  \/\/ List becomes: 1, 2, 3, 4<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    push_back()<\/code><\/strong>: Appends an element to the end of the list.<\/p>\n\n\n
                    numbers.push_back(5<\/span>);  \/\/ List becomes: 1, 2, 3, 4, 5<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    insert()<\/code><\/strong>: Inserts one or multiple elements at a specific position in the list.<\/p>\n\n\n
                    auto<\/span> it = numbers.begin();\nstd<\/span>::advance(it, 2<\/span>);  \/\/ Move iterator to the third position<\/span>\nnumbers.insert(it, 6<\/span>);  \/\/ List becomes: 1, 2, 6, 3, 4, 5<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Removing Elements<\/h3>\n\n\n\n
                    pop_front()<\/code><\/strong>: Removes the first element from the list.<\/p>\n\n\n
                    numbers.pop_front();  \/\/ List becomes: 2, 6, 3, 4, 5<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    pop_back()<\/code><\/strong>: Removes the last element from the list.<\/p>\n\n\n
                    numbers.pop_back();  \/\/ List becomes: 2, 6, 3, 4<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    erase()<\/code><\/strong>: Deletes one or a range of elements from the list.<\/p>\n\n\n
                    it = numbers.begin();\nstd<\/span>::advance(it, 1<\/span>);\nnumbers.erase(it);  \/\/ List becomes: 2, 3, 4<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    remove()<\/code><\/strong>: Removes all elements with a specific value from the list.<\/p>\n\n\n
                    numbers.remove(3<\/span>);  \/\/ List becomes: 2, 4<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    clear()<\/code><\/strong>: Removes all elements from the list, making it empty.<\/p>\n\n\n
                    numbers.clear();  \/\/ List is now empty<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Merging and Splitting Lists<\/h3>\n\n\n\n
                    Merging<\/strong>: You can merge two sorted lists using the merge()<\/code> function. It combines two lists into one, placing all elements in sorted order.<\/p>\n\n\n
                    std<\/span>::list<\/span><int<\/span>> list1 = {1<\/span>, 3<\/span>, 5<\/span>};\nstd<\/span>::list<\/span><int<\/span>> list2 = {2<\/span>, 4<\/span>, 6<\/span>};\nlist1.merge(list2);  \/\/ list1 becomes: 1, 2, 3, 4, 5, 6<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Splitting<\/strong>: While there’s no direct “split” function, you can use splice()<\/code> to move elements from one list to another.<\/p>\n\n\n
                    std<\/span>::list<\/span><int<\/span>> listA = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>};\nstd<\/span>::list<\/span><int<\/span>> listB;\nauto<\/span> splitPos = listA.begin();\nstd<\/span>::advance(splitPos, 3<\/span>);\nlistB.splice(listB.begin(), listA, listA.begin(), splitPos);  \/\/ listB becomes: 1, 2, 3<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Reversing and Sorting<\/h3>\n\n\n\n
                    Reversing<\/strong>: To reverse the order of elements in a std::list<\/code>, use the reverse()<\/code> function.<\/p>\n\n\n
                    std<\/span>::list<\/span><int<\/span>> nums = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\nnums.reverse();  \/\/ nums becomes: 5, 4, 3, 2, 1<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Sorting<\/strong>: Use the sort()<\/code> function to arrange the elements in ascending (or custom) order.<\/p>\n\n\n
                    std<\/span>::list<\/span><int<\/span>> unsorted = {5<\/span>, 3<\/span>, 8<\/span>, 1<\/span>, 4<\/span>};\nunsorted.sort();  \/\/ unsorted becomes: 1, 3, 4, 5, 8<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Manipulating std::list<\/code> is straightforward once you familiarize yourself with its set of functions. The key is to know which operation is optimal for a particular task, given the unique characteristics of this container.<\/p>\n\n\n\n
                    Advanced Operations on std::list<\/code><\/h2>\n\n\n\n
                    Once you’ve grasped the basics, std::list<\/code> offers a set of advanced operations that can greatly optimize and facilitate more intricate tasks. Here, we delve into some of these functions, shedding light on their utility and syntax.<\/p>\n\n\n\n
                    splice()<\/code><\/strong>: Transfer Elements from One List to Another<\/h3>\n\n\n\n
                    The splice()<\/code> function transfers elements from one list to another without copying or reallocating them. This makes the operation highly efficient.<\/p>\n\n\n\n
                    Transfer Entire List<\/strong>:<\/p>\n\n\n
                    std<\/span>::list<\/span><int<\/span>> listA = {1<\/span>, 2<\/span>, 3<\/span>};\nstd<\/span>::list<\/span><int<\/span>> listB = {4<\/span>, 5<\/span>, 6<\/span>};\nlistA.splice(listA.end(), listB);  \/\/ Moves all elements from listB to listA. listA: 1, 2, 3, 4, 5, 6; listB is now empty.<\/span>\n<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Transfer Specific Element<\/strong>:<\/p>\n\n\n
                    auto<\/span> iter = listA.begin();\nstd<\/span>::advance(iter, 2<\/span>);  \/\/ Move iterator to the third element<\/span>\nlistB.splice(listB.begin(), listA, iter);  \/\/ Moves '3' from listA to the beginning of listB.<\/span>\n<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Transfer Range of Elements<\/strong>:<\/p>\n\n\n
                    auto<\/span> start = listA.begin();\nauto<\/span> end = listA.begin();\nstd<\/span>::advance(end, 2<\/span>);\nlistB.splice(listB.end(), listA, start, end);  \/\/ Moves the first two elements from listA to the end of listB.<\/span>\n<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    unique()<\/code><\/strong>: Remove Duplicate Values<\/h3>\n\n\n\n
                    The unique()<\/code> function removes all but the first element from every consecutive group of equal elements in the list.<\/p>\n\n\n
                    std<\/span>::list<\/span><int<\/span>> numbers = {1<\/span>, 1<\/span>, 2<\/span>, 2<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 4<\/span>, 5<\/span>};\nnumbers.unique();  \/\/ List becomes: 1, 2, 3, 4, 5<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    You can also use unique()<\/code> with a binary predicate to specify custom criteria for uniqueness.<\/p>\n\n\n\n
                    resize()<\/code><\/strong>: Change the Size of the List<\/h3>\n\n\n\n
                    The resize()<\/code> function changes the size of the list, either by adding default-initialized elements or by truncating the list.<\/p>\n\n\n\n
                    Increase Size<\/strong>:<\/p>\n\n\n
                    std<\/span>::list<\/span><int<\/span>> numbers = {1<\/span>, 2<\/span>, 3<\/span>};\nnumbers.resize(5<\/span>);  \/\/ List becomes: 1, 2, 3, 0, 0<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Decrease Size<\/strong>:<\/p>\n\n\n
                    numbers.resize(2<\/span>);  \/\/ List becomes: 1, 2<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Resize with Value<\/strong>:<\/p>\n\n\n
                    numbers.resize(4<\/span>, 9<\/span>);  \/\/ List becomes: 1, 2, 9, 9<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    swap()<\/code><\/strong>: Swap Two Lists<\/h3>\n\n\n\n
                    As the name suggests, swap()<\/code> exchanges the contents of two lists. This operation is highly efficient and doesn’t involve actual element transfer.<\/p>\n\n\n
                    std<\/span>::list<\/span><int<\/span>> listA = {1<\/span>, 2<\/span>, 3<\/span>};\nstd<\/span>::list<\/span><int<\/span>> listB = {4<\/span>, 5<\/span>, 6<\/span>};\nlistA.swap(listB);  \/\/ listA: 4, 5, 6; listB: 1, 2, 3<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Iterating Over a std::list<\/code><\/h2>\n\n\n\n
                    Iterating over containers is a fundamental task in C++, and given the non-contiguous nature of std::list<\/code>, it’s even more critical to understand the techniques available to navigate through its elements. Here, we’ll examine two primary methods: traditional iterators and the C++11 range-based for loops.<\/p>\n\n\n\n
                    Using Traditional Iterators<\/h3>\n\n\n\n
                    Iterators act much like pointers, pointing to elements within a container. std::list<\/code> provides bidirectional iterators, which means you can traverse the list both forwards and backwards.<\/p>\n\n\n\n
                    Forward Iteration<\/strong>:<\/p>\n\n\n
                    std<\/span>::list<\/span><int<\/span>> numbers = {10<\/span>, 20<\/span>, 30<\/span>, 40<\/span>, 50<\/span>};\n\nfor<\/span> (std<\/span>::list<\/span><int<\/span>>::iterator it = numbers.begin(); it != numbers.end(); ++it) {\n    std<\/span>::cout<\/span> << *it << \" \"<\/span>;\n}\n\/\/ Output: 10 20 30 40 50<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Reverse Iteration<\/strong>:<\/p>\n\n\n\n
                    Bidirectional iterators allow for reverse traversal as well.<\/p>\n\n\n
                    for<\/span> (std<\/span>::list<\/span><int<\/span>>::reverse_iterator rit = numbers.rbegin(); rit != numbers.rend(); ++rit) {\n    std<\/span>::cout<\/span> << *rit << \" \"<\/span>;\n}\n\/\/ Output: 50 40 30 20 10<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Using C++11 Range-based For Loops<\/h3>\n\n\n\n
                    The range-based for loop, introduced in C++11, provides a more concise and readable way to iterate over containers. This syntax abstracts away the intricacies of iterators, resulting in cleaner code.<\/p>\n\n\n\n
                    Standard Iteration<\/strong>:<\/p>\n\n\n
                    for<\/span> (int<\/span> num : numbers) {\n    std<\/span>::cout<\/span> << num << \" \"<\/span>;\n}\n\/\/ Output: 10 20 30 40 50<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Iterating with Auto<\/strong>:<\/p>\n\n\n\n
                    Using auto<\/code> can make the loop even more concise, especially if dealing with complex data types. auto<\/code> deduces the type of the variable from its initializer.<\/p>\n\n\n
                    for<\/span> (auto<\/span> num : numbers) {\n    std<\/span>::cout<\/span> << num << \" \"<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Modification during Iteration<\/strong>:<\/p>\n\n\n\n
                    If you intend to modify the elements of the list during iteration, it’s recommended to use a reference.<\/p>\n\n\n
                    for<\/span> (auto<\/span> &num : numbers) {\n    num *= 2<\/span>;  \/\/ Double each number<\/span>\n}\n\/\/ numbers: 20, 40, 60, 80, 100<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Performance Considerations with std::list<\/code><\/h2>\n\n\n\n
                    When it comes to using STL containers, it’s crucial to understand their performance characteristics. std::list<\/code> has its own set of advantages and caveats which can make a difference depending on the use-case.<\/p>\n\n\n\n
                    Time Complexities of Operations<\/h3>\n\n\n\n
                    Here are some fundamental operations and their associated time complexities for std::list<\/code>:<\/p>\n\n\n\n
                      \n
                    • Insertion or Deletion at the Front or Back<\/strong>: O<\/em>(1)<\/li>\n\n\n\n
                    • Insertion or Deletion using an Iterator (known position)<\/strong>: O<\/em>(1)<\/li>\n\n\n\n
                    • Accessing Elements (e.g., via index)<\/strong>: O<\/em>(n<\/em>) [Note: std::list<\/code> doesn’t support random access like arrays\/vectors]<\/li>\n\n\n\n
                    • Searching for an Element<\/strong>: O<\/em>(n<\/em>)<\/li>\n\n\n\n
                    • Sorting<\/strong>: O<\/em>(n<\/em> log n<\/em>)<\/li>\n<\/ul>\n\n\n\n
                      When to Use std::list<\/code> vs. std::vector<\/code> or Other Containers<\/h3>\n\n\n\n
                        \n
                      • Use std::list<\/code> when<\/strong>:\n
                          \n
                        • You have frequent insertions and deletions in the middle of the sequence. Since lists are implemented as doubly-linked lists, adding or removing an element in the middle takes constant time given an iterator to the position.<\/li>\n\n\n\n
                        • Memory overhead isn’t a concern. Each node in a std::list<\/code> has overhead for previous and next pointers.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                        • Prefer std::vector<\/code> or std::array<\/code> when<\/strong>:\n
                            \n
                          • You need random access to elements. Vectors and arrays provide O<\/em>(1) random access, whereas lists take O<\/em>(n<\/em>).<\/li>\n\n\n\n
                          • Memory usage is a concern. Vectors and arrays typically use memory more efficiently due to their contiguous memory layout.<\/li>\n\n\n\n
                          • Cache locality matters. The contiguous nature of vectors and arrays makes them more cache-friendly, often resulting in better performance for operations that process elements in sequence.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                            Real-world Benchmarks<\/h3>\n\n\n\n
                            In real-world scenarios, raw time complexities might not tell the whole story due to factors like cache locality, memory overhead, and compiler optimizations. Here’s a simplistic approach to benchmarking:<\/p>\n\n\n
                            #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <list><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n#include<\/span> <chrono><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    const<\/span> int<\/span> N = 1000000<\/span>;\n\n    \/\/ Benchmark for std::list<\/span>\n    {\n        std<\/span>::list<\/span><int<\/span>> lst;\n        auto<\/span> start = std<\/span>::chrono::high_resolution_clock::now();\n        for<\/span> (int<\/span> i = 0<\/span>; i < N; ++i) {\n            lst.push_back(i);\n        }\n        auto<\/span> end = std<\/span>::chrono::high_resolution_clock::now();\n        std<\/span>::chrono::duration<double<\/span>> diff = end - start;\n        std<\/span>::cout<\/span> << \"std::list time: \"<\/span> << diff.count() << \" s\\n\"<\/span>;\n    }\n\n    \/\/ Benchmark for std::vector<\/span>\n    {\n        std<\/span>::vector<\/span><int<\/span>> vec;\n        auto<\/span> start = std<\/span>::chrono::high_resolution_clock::now();\n        for<\/span> (int<\/span> i = 0<\/span>; i < N; ++i) {\n            vec.push_back(i);\n        }\n        auto<\/span> end = std<\/span>::chrono::high_resolution_clock::now();\n        std<\/span>::chrono::duration<double<\/span>> diff = end - start;\n        std<\/span>::cout<\/span> << \"std::vector time: \"<\/span> << diff.count() << \" s\\n\"<\/span>;\n    }\n\n    return<\/span> 0<\/span>;\n}\n<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                            This benchmark will give you an idea of the performance difference between std::list<\/code> and std::vector<\/code> for a simple push_back<\/code> operation for a large number of elements. For a comprehensive benchmark, consider varying operations, sizes, and scenarios.<\/p>\n\n\n\n
                            Common Pitfalls and Mistakes with std::list<\/code><\/h2>\n\n\n\n
                            Using std::list<\/code> or, in fact, any container from the C++ STL requires careful attention to avoid common pitfalls. Let’s explore some frequent mistakes developers make when using std::list<\/code>.<\/p>\n\n\n\n
                            Invalid Iterator After Modification<\/h3>\n\n\n\n
                            One of the most common pitfalls when working with containers is the potential invalidation of iterators, pointers, or references after certain modifying operations.<\/p>\n\n\n\n
                            Safe with std::list<\/code>:<\/h4>\n\n\n\n
                              \n
                            • Inserting elements doesn’t invalidate any iterators.<\/li>\n\n\n\n
                            • Erasing elements invalidates only the iterators (and references) to the erased elements.<\/li>\n<\/ul>\n\n\n\n
                              Mistake Example<\/strong>:<\/p>\n\n\n
                              std<\/span>::list<\/span><int<\/span>> numbers = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>};\nauto<\/span> it = std<\/span>::next(numbers.begin(), 2<\/span>);  \/\/ it points to '3'<\/span>\nnumbers.erase(numbers.begin());\nstd<\/span>::cout<\/span> << *it;  \/\/ This is safe; 'it' remains valid and will print '3'.<\/span>\n<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                              However, always be aware of the specific operation and its implications on iterator validity.<\/p>\n\n\n\n
                              Misusing methods like splice()<\/code> or remove()<\/code><\/h3>\n\n\n\n
                              The splice()<\/code> and remove()<\/code> functions are powerful but can introduce bugs if misused.<\/p>\n\n\n\n
                              splice()<\/code> Pitfall:<\/h4>\n\n\n\n
                              One common mistake with splice()<\/code> is attempting to splice a list into itself using invalid ranges, which results in undefined behavior.<\/p>\n\n\n\n
                              Mistake Example<\/strong>:<\/p>\n\n\n
                              std<\/span>::list<\/span><int<\/span>> numbers = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>};\nauto<\/span> start = std<\/span>::next(numbers.begin());\nauto<\/span> end = std<\/span>::next(numbers.begin(), 3<\/span>);\nnumbers.splice(numbers.begin(), numbers, start, end);  \/\/ Undefined behavior: Invalid range within the same list<\/span>\n<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                              remove()<\/code> Pitfall:<\/h4>\n\n\n\n
                              The remove()<\/code> function removes all elements with a specific value. A common mistake is to believe it works with a predicate, which is actually the role of remove_if()<\/code>.<\/p>\n\n\n\n
                              Mistake Example<\/strong>:<\/p>\n\n\n
                              std<\/span>::list<\/span><int<\/span>> numbers = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\nnumbers.remove([](int<\/span> n) { return<\/span> n % 2<\/span> == 0<\/span>; });  \/\/ This is incorrect! remove() does not take a predicate.<\/span>\n<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                              Corrected Code<\/strong>:<\/p>\n\n\n
                              numbers.remove_if([](int<\/span> n) { return<\/span> n % 2<\/span> == 0<\/span>; });  \/\/ This will correctly remove all even numbers<\/span>\n<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                              When working with std::list<\/code>, always refer to the documentation or familiar sources to understand the intricacies of its operations. Avoid making assumptions, especially around iterator validity and function behavior, to ensure robust and error-free code.<\/p>\n\n\n\n
                              Use Cases and Practical Examples with std::list<\/code><\/h2>\n\n\n\n
                              The linked list structure of std::list<\/code> makes it particularly well-suited for tasks where elements are frequently inserted or removed from the middle of a collection. Let’s dive into a few practical use cases:<\/p>\n\n\n\n
                              Implementing a Simple Playlist<\/h3>\n\n\n\n
                              Imagine a music playlist where you can add songs, skip to the next song, or go back to the previous song.<\/p>\n\n\n
                              class<\/span> Song<\/span> {<\/span>\npublic<\/span>:\n    Song(std<\/span>::string<\/span> title) : title(title) {}\n    void<\/span> play<\/span>()<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Playing: \"<\/span> << title << std<\/span>::endl<\/span>;\n    }\n\nprivate<\/span>:\n    std<\/span>::string<\/span> title;\n};\n\nclass<\/span> Playlist<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> addSong<\/span>(const<\/span> Song& song)<\/span> <\/span>{\n        songs.push_back(song);\n        \/\/ If it's the first song, set it as the current<\/span>\n        if<\/span> (songs.size() == 1<\/span>) {\n            current = songs.begin();\n        }\n    }\n\n    void<\/span> playCurrent<\/span>()<\/span> <\/span>{\n        if<\/span> (current != songs.end()) {\n            current->play();\n        } else<\/span> {\n            std<\/span>::cout<\/span> << \"Playlist is empty or ended.\"<\/span> << std<\/span>::endl<\/span>;\n        }\n    }\n\n    void<\/span> next<\/span>()<\/span> <\/span>{\n        if<\/span> (current != songs.end() && std<\/span>::next(current) != songs.end()) {\n            ++current;\n            playCurrent();\n        } else<\/span> {\n            std<\/span>::cout<\/span> << \"End of playlist.\"<\/span> << std<\/span>::endl<\/span>;\n        }\n    }\n\n    void<\/span> previous<\/span>()<\/span> <\/span>{\n        if<\/span> (current != songs.begin()) {\n            --current;\n            playCurrent();\n        } else<\/span> {\n            std<\/span>::cout<\/span> << \"Start of playlist.\"<\/span> << std<\/span>::endl<\/span>;\n        }\n    }\n\nprivate<\/span>:\n    std<\/span>::list<\/span><Song> songs;\n    std<\/span>::list<\/span><Song>::iterator current;\n};<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                              Managing Tasks in a To-do List Application<\/h3>\n\n\n\n
                              For a simple to-do list application, tasks can be added, marked as done, or removed.<\/p>\n\n\n
                              class<\/span> ToDoList<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> addTask<\/span>(const<\/span> std<\/span>::string<\/span>& task)<\/span> <\/span>{\n        tasks.push_back(task);\n    }\n\n    void<\/span> markDone<\/span>(int<\/span> index)<\/span> <\/span>{\n        if<\/span> (index >= 0<\/span> && index < tasks.size()) {\n            auto<\/span> it = std<\/span>::next(tasks.begin(), index);\n            tasks.erase(it);\n            std<\/span>::cout<\/span> << \"Task marked as done.\"<\/span> << std<\/span>::endl<\/span>;\n        } else<\/span> {\n            std<\/span>::cout<\/span> << \"Invalid task index.\"<\/span> << std<\/span>::endl<\/span>;\n        }\n    }\n\n    void<\/span> showTasks<\/span>()<\/span> <\/span>{\n        int<\/span> index = 0<\/span>;\n        for<\/span> (const<\/span> auto<\/span>& task : tasks) {\n            std<\/span>::cout<\/span> << index++ << \". \"<\/span> << task << std<\/span>::endl<\/span>;\n        }\n    }\n\nprivate<\/span>:\n    std<\/span>::list<\/span><std<\/span>::string<\/span>> tasks;\n};<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                              Creating a Basic Undo-Redo Functionality Using std::list<\/code><\/h3>\n\n\n\n
                              A classic use of a doubly-linked list is to manage a series of states in an application to allow undo and redo functionality.<\/p>\n\n\n
                              template<\/span> <typename<\/span> T>\nclass<\/span> UndoRedoList<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> addAction<\/span>(const<\/span> T& action)<\/span> <\/span>{\n        \/\/ Remove any \"future\" actions if we're in the middle of the list<\/span>\n        actions.erase(std<\/span>::next(current), actions.end());\n\n        \/\/ Add the new action and set it as the current<\/span>\n        actions.push_back(action);\n        current = std<\/span>::prev(actions.end());\n    }\n\n    T undo<\/span>()<\/span> <\/span>{\n        if<\/span> (current == actions.begin()) {\n            throw<\/span> std<\/span>::runtime_error(\"Nothing to undo.\"<\/span>);\n        }\n        --current;\n        return<\/span> *current;\n    }\n\n    T redo<\/span>()<\/span> <\/span>{\n        if<\/span> (std<\/span>::next(current) == actions.end()) {\n            throw<\/span> std<\/span>::runtime_error(\"Nothing to redo.\"<\/span>);\n        }\n        ++current;\n        return<\/span> *current;\n    }\n\nprivate<\/span>:\n    std<\/span>::list<\/span><T> actions;\n    typename<\/span> std<\/span>::list<\/span><T>::iterator current = actions.end();\n};<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
                              These examples show the versatility of std::list<\/code>. Depending on the use case, this container can offer efficient solutions for a wide range of tasks, especially when insertions or deletions in the middle of a sequence are frequent.<\/p>\n\n\n\n
                              The decision to use std::list<\/code> should stem from an informed perspective. While it’s a go-to container for specific scenarios, other STL containers might be more appropriate for different tasks. The goal is to strike a balance between the container’s strengths and the specific needs of the application at hand.<\/p>\n","protected":false},"excerpt":{"rendered":"
                              Introduction What is std::list? std::list is one of the sequence containers provided by the Standard Template Library (STL) in C++, that allows the storage and manipulation of a doubly-linked list of elements. Each element in the list is stored in a node, and each node contains a pointer to the previous node and the next […]<\/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_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_post_was_ever_published":false},"categories":[9,4],"tags":[],"class_list":["post-1226","post","type-post","status-publish","format-standard","category-cplusplus","category-programming-languages","entry"],"yoast_head":"\nC++ std::list (<list>)- From Basics to Advanced<\/title>\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\/c-stdlist-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::list (<list>)- From Basics to Advanced\" \/>\n<meta property=\"og:description\" content=\"Introduction What is std::list? std::list is one of the sequence containers provided by the Standard Template Library (STL) in C++, that allows the storage and manipulation of a doubly-linked list of elements. Each element in the list is stored in a node, and each node contains a pointer to the previous node and the next […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/c-stdlist-from-basics-to-advanced\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-09-06T12:06:57+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-10-02T06:42:54+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=\"12 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/c-stdlist-from-basics-to-advanced\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/c-stdlist-from-basics-to-advanced\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"C++ std::list (<list>)- From Basics to Advanced\",\"datePublished\":\"2023-09-06T12:06:57+00:00\",\"dateModified\":\"2023-10-02T06:42:54+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/c-stdlist-from-basics-to-advanced\\\/\"},\"wordCount\":2689,\"commentCount\":0,\"articleSection\":[\"C++\",\"Programming Languages\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/c-stdlist-from-basics-to-advanced\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/c-stdlist-from-basics-to-advanced\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/c-stdlist-from-basics-to-advanced\\\/\",\"name\":\"C++ std::list (<list>)- From Basics to Advanced\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2023-09-06T12:06:57+00:00\",\"dateModified\":\"2023-10-02T06:42:54+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/c-stdlist-from-basics-to-advanced\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/c-stdlist-from-basics-to-advanced\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/c-stdlist-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::list (<list>)- 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=1783167470\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1783167470\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1783167470\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"C++ std::list (<list>)- From Basics to Advanced","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\/c-stdlist-from-basics-to-advanced\/","og_locale":"en_US","og_type":"article","og_title":"C++ std::list (<list>)- From Basics to Advanced","og_description":"Introduction What is std::list? std::list is one of the sequence containers provided by the Standard Template Library (STL) in C++, that allows the storage and manipulation of a doubly-linked list of elements. Each element in the list is stored in a node, and each node contains a pointer to the previous node and the next […]","og_url":"https:\/\/www.w3computing.com\/articles\/c-stdlist-from-basics-to-advanced\/","article_published_time":"2023-09-06T12:06:57+00:00","article_modified_time":"2023-10-02T06:42:54+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"12 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/c-stdlist-from-basics-to-advanced\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/c-stdlist-from-basics-to-advanced\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"C++ std::list (<list>)- From Basics to Advanced","datePublished":"2023-09-06T12:06:57+00:00","dateModified":"2023-10-02T06:42:54+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/c-stdlist-from-basics-to-advanced\/"},"wordCount":2689,"commentCount":0,"articleSection":["C++","Programming Languages"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.w3computing.com\/articles\/c-stdlist-from-basics-to-advanced\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/c-stdlist-from-basics-to-advanced\/","url":"https:\/\/www.w3computing.com\/articles\/c-stdlist-from-basics-to-advanced\/","name":"C++ std::list (<list>)- From Basics to Advanced","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2023-09-06T12:06:57+00:00","dateModified":"2023-10-02T06:42:54+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/c-stdlist-from-basics-to-advanced\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/c-stdlist-from-basics-to-advanced\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/c-stdlist-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::list (<list>)- 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=1783167470","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1783167470","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1783167470","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\/1226","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=1226"}],"version-history":[{"count":10,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1226\/revisions"}],"predecessor-version":[{"id":1543,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1226\/revisions\/1543"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=1226"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=1226"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=1226"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}