Understanding the Difference Between std::erase and std::remove

The std::remove algorithm is a versatile tool designed to operate on any forward iterator pair, making it applicable to a wide range of containers and scenarios. Unlike its counterpart std::erase, which effectively deletes and removes elements from a container, std::remove only rearranges elements.

1. Uncovering the Nuances of std::remove

std::remove works by logically partitioning the container into two sections: a section containing the elements to be removed and a section containing the remaining elements. It does this by iterating through the container and moving non-removed elements forward, effectively overwriting removed elements. However, it's important to note that std::remove doesn't actually erase the deleted elements; they remain in memory but are effectively hidden from view.

This behavior becomes evident when using std::remove in conjunction with the container size() function. After removing an element using std::remove, std::size() will continue to return the original size of the container, even though some elements are logically deleted. The container's size only changes after using std::erase to physically remove the hidden elements.

2. Visualizing the Impact of std::remove

Consider the code snippet provided in the original question:

std::vector a;
a.push_back(1);
a.push_back(2);

std::remove(a.begin(), a.end(), 1);

int s = a.size();

After executing std::remove, the vector still contains two elements (2 and 2), but the first element (1) is logically deleted and hidden from view. Therefore, std::size() returns 2, despite the presence of a hidden deleted element.

3. Employing std::erase for Physical Removal

To physically remove deleted elements and update the container's size, std::erase comes into play. By invoking std::erase with the iterator pair returned by std::remove as the first argument, you can eliminate the hidden deleted elements and reduce the container's size:

a.erase(std::remove(a.begin(), a.end(), 1), a.end());

In this case, std::erase physically removes element 1, leaving the vector with a single element (2) and a updated size of 1.

4. Understanding the Scope of std::remove's Utility

While std::remove isn't designed solely to be used in conjunction with std::erase, it finds extensive use in various scenarios where logical partitioning of elements is required. For instance, you can employ std::remove to:

• Partition elements that meet a specific criteria from those that don't.
• Group similar elements together.
• Find the position of a specific element or set of elements.