Erase-Remove Idiom in C++ – GeeksforGeeks

Erase-Take away-Idiom is a C++ STL (Commonplace Template Library) method to take away components from a container. It’s used to take away all the weather satisfying sure situations from the container.

The erase-remove idiom is particularly helpful in array-based containers like vectors, the place every elimination requires all of the remaining components to regulate. Within the worst case, this will result in O ( n²) time complexity. This system avoids this by offering the elimination of the weather in a single parse. That’s the reason, the erase-remove idiom supplies O( n ) time complexity.

On this method, we use the mix of two member capabilities of the container to take away the weather effectively.

std::erase
std::take away or std::remove_if

It is because of the usage of this perform that this system is named the erase-remove idiom.

std::erase

The std::erase perform is used to take away components from the container giving the iterator its place. It might additionally take away the vary of components when the iterator to beginning place and ending place are offered.

Syntax of std::erase

container.erase(place); // to remove single ingredient
        or
container.erase(starting_position, ending_position); // to remove a spread of components

Right here,

place: It’s the iterator to the ingredient to be eliminated.
starting_position: iterator to the start line of the vary to be eradicated.
ending_position: It’s the iterator to the ending level of the vary to be eradicated.

std::take away

The std::take away perform is used to relocate the weather which equate to the given worth and return the iterator to the brand new logical finish.

Syntax of std::take away

container.take away(first, final, val);

Right here,

first: It’s the iterator to the primary ingredient of the vary the perform has to work.
final: It’s the iterator to the final ingredient of the vary.
val: It’s the worth to be examined in opposition to.

std::remove_if

The std::remove_if perform is the variation of the take away perform by which we are able to move a comparator perform as a substitute of a worth to check.

Syntax of std::remove_if

container.remove_if(first, final, val);

Right here,

first: It’s the iterator to the primary ingredient of the vary the perform has to work.
final: It’s the iterator to the final ingredient of the vary.
predicate: It’s the perform that specifies the comparator.

Working of Erase Take away Idiom

This can be a two-step method that includes utilizing each std::take away and std::erase capabilities one after one other. The next are the steps:

STEP 1: The std::take away perform strikes all components to be eliminated on the finish of the container. It returns the brand new logical finish of the vary.
STEP 2: The std::erase perform is then used to erase all the weather after the brand new logical finish without delay.

Implementation of Erase Take away Idiom

The next instance demonstrates the best way to use Erase Take away Idiom for eradicating odd numbers from a vector container.

C++

#embrace <algorithm>

#embrace <iostream>

#embrace <vector>

void printV(std::vector<int>& v)

{

for (auto i : v) {

std::cout << i << " ";

}

std::cout << std::endl;

}

int essential()

{

std::vector<int> v{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };

std::cout << "Authentic Vectorttt: ";

printV(v);

auto new_logical_end = std::remove_if(

v.start(), v.finish(), [](int a) { return a % 2; });

std::cout << "After utilizing remove_if()t: ";

printV(v);

v.erase(new_logical_end, v.finish());

std::cout << "After utilizing erase()tt: ";

printV(v);

}

Output

Authentic Vector            : 1 2 3 4 5 6 7 8 9 
After utilizing remove_if()    : 2 4 6 8 5 6 7 8 9 
After utilizing erase()        : 2 4 6 8

Benefits of Erase Take away Idiom

Extremely environment friendly as all of the objects will be eliminated in a single parse.
Protected and versatile as a consequence of the usage of STL predefined perform templates.

Limitations of Erase Take away Idiom

It solely works with sure kinds of containers like vectors, lists, and deques, and never with others like maps and units.
Disrupts the order of remaining components.
It could be gradual if the predicate perform is dear.

Source link