forward_list::splice_after() in C++

C++ gives an effective and flexible set of equipment for builders, and one often disregarded gem is the forward_list magnificence. Among its many capabilities, the forward_list::splice_after() feature stands proud as an effective device for manipulating linked lists. In this blog post, we're going to explore the bits and bobs of forward_list::splice_after(), examining its syntax, use cases, and supplying a fingers-on instance with code and output.

Understanding forward_list::splice_after():

The forward_list::splice_after() feature lets you to transfer factors from one forward_list to some other at a certain function. It takes 3 parameters: an iterator to the location inside the destination forward_list in which the elements could be inserted, an iterator range specifying the elements to be moved from the supply forward_list, and an non-compulsory reference to the supply forward_list.

Syntax:

It has the following syntaxes:

void splice_after(const_iterator position, forward_list& x);
void splice_after(const_iterator position, forward_list&& x);
void splice_after(const_iterator position, forward_list& x, const_iterator it);
void splice_after(const_iterator position, forward_list&& x, const_iterator it);
void splice_after(const_iterator position, forward_list& x, const_iterator first, const_iterator last);
void splice_after(const_iterator position, forward_list&& x, const_iterator first, const_iterator last);

Let's understand the parameters:

role: Iterator pointing to the location in the destination forward_list where the factors might be inserted.

X: The source forward_list from which factors could be moved.

It: Iterator pointing to the element in the supply forward_list marking the start line for the switch.

First, last: Iterator range specifying the factors to be moved from the source forward_list.

Now, permit's dive into a realistic example to illustrate a way to use forward_list::splice_after().

Example:

#include <iostream>
#include <forward_list>
 
int main() {
    // Creating source and destination forward_lists
    std::forward_list<int> sourceList = {1, 2, 3, 4};
    std::forward_list<int> destinationList = {10, 20, 30};
 
    // Displaying the initial state of both forward_lists
    std::cout << "Source List: ";
    for (const auto& element : sourceList) {
        std::cout << element << " ";
    }
 
    std::cout << "\nDestination List: ";
    for (const auto& element : destinationList) {
        std::cout << element << " ";
    }
 
    // Splicing elements from sourceList to destinationList after the second element
    auto it = destinationList.begin();
    std::advance(it, 1); // Moving iterator to the second element
    destinationList.splice_after(it, sourceList);
 
    // Displaying the state after splicing
    std::cout << "\n\nAfter Splicing:\n";
    std::cout << "Source List: ";
    for (const auto& element : sourceList) {
        std::cout << element << " ";
    }
 
    std::cout << "\nDestination List: ";
    for (const auto& element : destinationList) {
        std::cout << element << " ";
    }
 
    return 0;
}

Output:

Source List: 1 2 3 4
Destination List: 10 20 30
 
After Splicing:
Source List:
Destination List: 10 1 2 3 4 20 30

Explanation:

In this case, we've a supply forward_list named sourceList containing factors 1, 2, 3, and four. The destination forward_list named destinationList to start with contains elements 10, 20, and 30.

After that, we use splice_after() to switch the elements from sourceList to destinationList after the second element in destinationList. The output demonstrates the result after the splicing operation.

Splicing Specific Elements:

In addition to splicing the entire content of 1 forward_list into another, forward_list::splice_after() lets for splicing unique elements. The iterators it, first, and ultimate parameters allow great-grained manipulation over which factors are transferred. This flexibility is beneficial when managing large, related lists or while unique quantities need to be rearranged.

// Splicing elements 2 and 3 from sourceList to destinationList after the second element
auto itStart = std::next(sourceList.begin(), 1); // Iterator pointing to the second element in sourceList
auto itEnd = std::next(sourceList.begin(), 3);   // Iterator pointing to the element after the third element in sourceList
destinationList.splice_after(destinationList.begin(), sourceList, itStart, itEnd);

Complexity Considerations:

The forward_list::splice_after() operation has steady time complexity, O(1), regardless of the scale of the source or destination lists. It makes it an efficient choice for operations concerning the rearrangement of elements inside connected lists.

Avoiding Invalidation:

It's important to be aware that iterators and references to factors inside the source forward_list continue to be valid after the splicing operation, so long as the spliced elements aren't erased from the supply listing. However, iterators and references to factors within the destination forward_list may be invalidated if the spliced factors cause reallocation.

Conclusion:

In Conclusion, studying the forward_list::splice_after() feature in C++ empowers builders to effectively manage related lists, facilitating seamless detail transfers between lists. Whether managing entire lists or specific elements, the flexibility and overall performance of this feature make it a valuable tool in the C++ developer's toolkit.

Next TopicGlobal constant in C++

← prev next →