for( std::vector< STATUS >::iterator it = m.begin() ; it != m.end() ; )
     {
          if( it->state == StatusOk )
          {
               it = m.erase( it );
          }
          else
          {
               ++it;
          }
     }

А>     for( std::vector< STATUS >::iterator it = m.begin() ; it != m.end() ; )
А>     {
А>          if( it->state == StatusOk )
А>          {
А>               it = m.erase( it );
А>          }
А>          else
А>          {
А>               ++it;
А>          }
А>     }
А>

m.erase( remove_if( m.begin(), m.end(),
     boost::bind(
          std::equal_to< тип, где StatusOk >(),
          boost::bind( &STATUS::state, _1 ), StatusOk )
     ),
     m.end() );

А>     for( std::vector< STATUS >::iterator it = m.begin() ; it != m.end() ; )
А>     {
А>          if( it->state == StatusOk )
А>          {
А>               it = m.erase( it );
А>          }
А>          else
А>          {
А>               ++it;
А>          }
А>     }
А>

#include <boost/range/algorithm_ext/erase.hpp>

struct STATUS
{
    int state;
};

const int StatusOk = 2;

int main()
{
    std::vector<STATUS> v = {{0},{1},{2},{3}};
    boost::remove_erase_if(v, [](STATUS _e) { return _e.state == StatusOk; });
}

А>     for( std::vector< STATUS >::iterator it = m.begin() ; it != m.end() ; )
А>     {
А>          if( it->state == StatusOk )
А>          {
А>               it = m.erase( it );
А>          }
А>          else
А>          {
А>               ++it;
А>          }
А>     }
А>

std::vector< STATUS >::iterator s = m.end();
    
for( std::vector< STATUS >::iterator it = m.begin() ; it != s ; )
     {
          if( it->state == StatusOk )
          {
               --s; std::swap(*it,*s);
          }
          else
          {
               ++it;
          }
     }

m.erase(s,m.end());

A>std::vector< STATUS >::iterator s = m.end();
A>for( std::vector< STATUS >::iterator it = m.begin() ; it != s ; )
A>     {
A>          if( it->state == StatusOk )
A>          {
A>               --s; std::swap(*it,*s);
A>          }
A>          else
A>          {
A>               ++it;
A>          }
A>     }
A>m.erase(s,m.end());
A>

size_t size = m.size( );
for ( size_t i = 0; i != size; ++i ) {
    if ( m[i].state == StatusOk ) {
        std::swap( m[i--], m[--size] );
    }
}
m.resize( size );

template<class BidirIt, class UnaryPredicate>
BidirIt unstable_remove_if(BidirIt first, BidirIt last, UnaryPredicate p)
{
    while (1) {
        while ((first != last) && p(*first)) {
            ++first;
        }
        if (first == last--) break;
        while ((first != last) && !p(*last)) {
            --last;
        }
        if (first == last) break;
        *first++ = std::move(*last); //std::swap(*first++, *last);
    }
    return first;
}

template<typename I, typename P>
/*
requires
(
    Mutable(I) && BidirectionalIterator(I) &&
    UnaryPredicate(P) && ValueType(I) == Domain(P)
)
*/
I unstable_remove_if(I first, I last, P p)
{
    while (true)
    {
        while (true)
            if (first == last)
                return first;
            else if (!p(*first))
                ++first;
            else
                break;
        --last;
        while (true)
            if (first == last)
                return first;
            else if (p(*last))
                --last;
            else
                break;
        *first = std::move(*last);
        ++first;
    }
}