Removing element from vector based on value of the next element

I'm writing a program that will read over a vector of strings, and if it encounters an element with the value "..", it will erase itself and the previous element. (eg. { "1", "2", "..", "3" } would be converted to { "1", "3" })

I understand that I could write code to do this using loops, and erase() etc, but I was wondering
if it was possible to achieve this using the standard libraries container functions (like remove_if(), for_each() etc), as this would make my code look a lot cleaner.

I've had a look around, but not managed to find anything in the standard library that removes/erases elements in this style.

TLDR: Yes it can be done using vector functions, but isn't recommended in your case due to performance and readability. Below is both the code following what you asked, and what I'd recommend.

Let's first talk about the functions you mentioned:

• remove_if(): This function removes all elements that satisfy a predicate, and returns the iterator for the new vector range. It does not return the individual iterators of the removed elements, which therefore doesn't allow you to remove elements depending of them.
• for_each(): This function lets you run a function for each elements contained within a vector. However, as shown here, the function that will target each element of your vector are their direct values, not the iterators. Therefore, you can't erase elements depending of the ones you're iterating through. Plus, it could likely cause issues to delete elements from the vector while iterating through it using this function.

The closest function I could find for your usage is find_if(). It lets you find the first iterator that satisfy a predicate in a vector, and returns your vector's end iterator if none could be found.

This function takes advantage of it:

#include <string>
#include <vector>
#include <algorithm>

void processvec(std::vector<std::string>& vec) {
    std::vector<std::string>::iterator found;
    while ((found = std::find_if(vec.begin(), vec.end(), [](std::string str) {return str == ".."; })) != vec.end()) {
        vec.erase(vec.erase(found - 1));
    }
}

To explain it a little bit:

• We declare a "found" iterator
• We then enter a while loop that will, for each iteration, find the first iterator that corresponds to an element of our vector that is equal to ".."
• If the found iterator equals the vector's end iterator, we break the while loop
• If the while loop wasn't broken, then we erase from the vector the element prior to the found iterator
• The erase function returns the next valid operator of our vector after the one we just erase
• We therefore erase the newly returned iterator as well.
• Repeat the while loop

Do note two things though:

• Your input vector must be valid: if you input {"..", "1", "2"} for instance, an error will occur because there is no element prior to the first "..".
• While this answers your request of "using the standard libraries container functions", it is terribly inefficient, as the find_if() function will iterate through your vector every time it is called. So on a large scale vector with a thousand elements, but only the few last one actually are "..", then hundreds of elements will be iterated through multiple times for nothing.

As a result, I think that sticking with usual iterator for loops would be a better idea in your case.

Here is a function that should do the job efficiently enough:

#include <string>
#include <vector>
#include <algorithm>
    
void processvec(std::vector<std::string>& vec) {
    for (std::vector<std::string>::iterator it = vec.begin(); it != vec.end();) {
        if (*it == ".." && it != vec.begin())
            it = vec.erase(vec.erase(it - 1));
        else
            ++it;
    }
}

I'm not sure how objective readability is here, but I find the former function much harder to read than the latter, due to so many things being stacked on the former.