void main()
{
    std::vector<short> s;

    s.push_back(0);
    s.push_back(1);
    s.push_back(2);
    s.push_back(3);
    s.push_back(2);
    s.push_back(5);
 }

for(vector<short>::size_type i = 2; i < s.size(); i+= 2)
{
    s.erase(s.begin() + i);
}

E>for(vector<short>::size_type i = 2; i < s.size(); i+= 2)
E>{
E>    s.erase(s.begin() + i);
E>}
E>

    int a[] = {1,2,3,4,5,6,7,8,9};
    vector<int> v(a, a+sizeof(a)/sizeof(a[0]));
    for (int i = 0; i < v.size(); ++i)
    {
        v[i-(i/3)] = v[i];
    }
    v.resize(v.size()-v.size()/3);
    copy(v.begin(), v.end(), ostream_iterator<int>(cout," "));

struct Func
{
    Func()
        :    i(0)
    {
    }

    bool operator()(int )
    {
        return ++i % 3 == 0;
    }
private:
    int    i;
};

int main()
{
    typedef std::vector<int> vec_type;

    vec_type        v;
    for (int i=0; i<10; ++i)
    {
        v.push_back( i );
    }

    v.erase (
            remove_if( v.begin(), v.end(), Func() ), 
            v.end( ) 
        );

    std::copy(
            v.begin(),
            v.end(),
            std::ostream_iterator<int>( cout, "\n" )
        );

    return 0;
}

Stateful predicates may seem useful, but they are explicitly not very useful with the C++ standard library and its algorithms, and that is intentional. In particular, stateful predicates can only be useful if:

The predicate is not copied: The standard algorithms make no such guarantee, and in fact assume that predicates are safely copyable.

The predicate is applied in a documented deterministic order: The standard algorithms generally make no guarantee about the order in which the predicate will be applied to the elements in the range. In the absence of guarantees about the order in which objects will be visited, operations like "flag the third element" (see Examples) make little sense, because which element will be visited "third" is not well-defined.

(с) C++ Coding Standards: 101 Rules, Guidelines, and Best Practices
By Herb Sutter, Andrei Alexandrescu

HSH>Уже прямо боюсь что-то говорить Поэтому просто спрошу — а разве не рекомендуется делать функторы stateless, т. к. в алгоритмах они могут копироватьсся? Этот пример работет, т. к. функтор, с которого была снята копия больше не используется — такое поведение где-то (в Стандарте) оговаривается?

    v.erase (
            remove_if<vector<int>::iterator, vector<int>::iterator, Func&>( v.begin(), v.end(), Func() ), 
            v.end( ) 
        );

25.2.7/4 Notes: Stable: the relative order of the elements that are not removed is the same as their relative order in
the original range.

template<class _FI, class _Pr> inline
    _FI remove_if(_FI _F, _FI _L, _Pr _P)
    {_F = find_if(_F, _L, _P);
    if (_F == _L)
        return (_F);
    else
        {_FI _Fb = _F;
        return (remove_copy_if(++_F, _L, _Fb, _P)); }}

struct State
{
  .....
};

struct Functor
{
  State* state;
  explicit Functor(State* st) : state(st) {}
  some operator()(some args) const // stateless, поэтому и const
  {
    ..... state->change() .....
  }
};

......
State state(init);
x = std::play_with_functor(Functor(&state));
y = state.result();

x = std::play_with_functor(Functor(std::auto_ptr(new State(init)).get()));

x = std::play_with_functor(Functor(&State(init)));

HSH>    v.erase (
HSH>            remove_if<vector<int>::iterator, vector<int>::iterator, Func&>( v.begin(), v.end(), Func() ), 
HSH>            v.end( ) 
HSH>        );

int n=v.size();
int w=0; // w - write
for(int r=0; r!=n; ++r) // r - read
{
  if(r%3!=0)
    if(w!=r) v[w++] = v[r];
}
v.resize(w);