Deleting an element of a container by directly accessing its iterator alone in C++

This is the correct way IMO:

template <typename T> T remove_even(T start, T end) { return std::remove_if(start,end,[](const auto& item){return item%2==0;}; } int main() { std::vector<int> vec = {2, 4, 5, 6, 7}; vec.erase(remove_even(vec.begin(), vec.end()),vec.end()); } 

From cplusplus.com:

An iterator is any object that, pointing to some element in a range of elements (such as an array or a container), has the ability to iterate through the elements of that range using a set of operators (with at least the increment (++) and dereference (*) operators).

As stated in the quote, it points to an element in a range of elements. It does not need to provide any information about the range it is in, i.e. about the container the elements are stored in.

As already stated in a comment, removing an element from a vector (or any other container) is an operation that affects the container, not only the object. So you will always have to call erase() or a similar function on the container.

What you are asking about is (somewhat, not exactly) similar to this:

void remove_or_not(int& i){ //do something with i to remove it from a container //but we dont have a container here } int main(){ std::vector<int> vec; //fill vec and generate some int n remove_or_not(vec[n]); } 

When calling remove_or_not() in the above example, we just pass a reference to an int - we totally lost the information that it is inside a container, so it's obvious we can't remove it from any container.

When trying the same with iterators we still have the information that the element is inside a container - but we might have lost the information in which container, as it is not required by the iterator to keep this information.
E.g. an iterator over a C-style array can just be a pointer. We can increment and decrement it and compare it to a pointer to the first element and a pointer behind the last element. But there is no need to know anything about the size of the array or about the array at all.

PS: for approaches how to correclty implement what you need, see the already posted answers, i don't think theres a need to repeat those.

There is no way to do this by passing just the iterators to a function. You have to pass the whole vector to the function as shown below:

void remove_even(std::vector<int> v) { for (auto it = v.begin(); it != v.end();) { if ((*it) % 2 == 0) { it = v.erase(it); } else { ++it; } } } 

You may want to consider the idiom of passing the container by x-value reference and then returning a copy/moved version.

This gives the advantages of efficiency coupled with readability at the call site.

An extended example below.

Note that all the 'apparent' copying of the vector will be elided (optimised away) by the compiler (RVO).

Also note that because Container&& is evaluated in deduced context, it will automatically be either a const Container& or a Container&&, whichever is most appropriate in the context of the call site. This means the same function can be used to both mutate an existing container (x = sorted(x)) or to make a mutated copy (x = sorted(y))

#include <iostream> #include <vector> #include <algorithm> template<class Container, class Predicate> auto all_except(Container&& c, Predicate&& pred) { auto result = std::forward<Container>(c); result.erase(std::remove_if(std::begin(result), std::end(result), std::forward<Predicate>(pred)), std::end(result)); return result; } template<class Container> auto sorted(Container&& c) { auto result = std::forward<Container>(c); std::sort(std::begin(result), std::end(result)); return result; } auto even_items = [](auto const& item) { return item % 2 == 0; }; auto odd_items = [](auto const& item) { return item % 2 != 0; }; template<class Vec> void emit(const Vec& v) { std::cout << "["; auto sep = " "; for (auto const& e : v) { std::cout << sep << e; sep = ", "; } std::cout << " ]" << std::endl; } int main() { std::vector<int> vec = {65, 2, 32, 63, 9, 13, 88, 22, 4, 5, 6, 7}; emit(all_except(vec, even_items)); emit(all_except(vec, odd_items)); emit(all_except(sorted(vec), odd_items)); vec = sorted(all_except(std::move(vec), even_items)); emit(vec); return 0; } 

expected results:

[ 65, 63, 9, 13, 5, 7 ] [ 2, 32, 88, 22, 4, 6 ] [ 2, 4, 6, 22, 32, 88 ] [ 5, 7, 9, 13, 63, 65 ]