struct S {
    int eq;
    int value;
    bool operator==(const S& other) const { return eq == other.eq; }
};

namespace std {
    template <> struct hash<S>
    {
        size_t operator()(const S &s) const
        {
            return hash<int>()(s.eq);
        }
    };
}

array<S, 6> as{ { {1,0},{2,0},{3,0},{ 1,1 },{ 2,1 },{ 3,1 } } };
unordered_set<S> us(as.cbegin(), as.cend());

Сначала придумываю другую версию петля, в отличие от вашей, она объединяет на месте, вы можете найти это интересным:

std::vector<int> v({1, 7, 1, 8, 9, 8, 9, 1, 1, 7});

auto retained = v.begin();
for(auto i = v.begin(); i != v.end(); ++i)
{
    bool isFirst = true;
    for(auto j = v.begin(); j != retained; ++j)
    {
        if (*i == *j)
        {
            isFirst = false;
            break;
        }
    }

    if (isFirst)
    {
        *retained++ = *i;
    }
}
v.erase(retained, v.end());

Это была база для версии, использующей std::remove_if и std::find_if:

auto retained = v.begin();
auto c = [&v, &retained](int n)
        {
            if (std::find_if (v.begin(), retained, [n](int m) { return m == n; }) != retained)
                return true;
            // element remains, so we need to increase!!!
            ++retained;
            return false;
        };
v.erase(std::remove_if (v.begin(), v.end(), c), v.end());

В этом случае вам понадобится лямбда, так как нам нужен уникальный предикат, тогда как эквивалент (в моем примере int, представленный operator==) является двоичным ...

Расширяя мой комментарий в ответе AndyG:

template<class T, class A, class Equivalent>
auto deduplicated2(std::vector<T, A> vec, Equivalent&& equivalent) -> std::vector<T, A>
{
    auto current = std::begin(vec);

    // current 'last of retained sequence'
    auto last = std::end(vec);

    while (current != last)
    {
        // define a predicate which checks for equivalence to current
        auto same = [&](T const& x) -> bool
        {
            return equivalent(*current, x);
        };

        // move non-equivalent items to end of sequence
        // return new 'end of valid sequence'
        last = std::remove_if (std::next(current), last, same);
    }
    // erase all items beyond the 'end of valid sequence'
    vec.erase(last, std::end(vec));
    return vec;
}

Кредит AndyG, пожалуйста.

Для очень больших векторов, где T является хешируемым, мы можем стремиться к решению O (n):

template<class T, class A, class Equivalent>
auto deduplicated(std::vector<T, A> const& vec, Equivalent&& equivalent) -> std::vector<T, A>
{
    auto seen = std::unordered_set<T, std::hash<T>, Equivalent>(vec.size(), std::hash<T>(), std::forward<Equivalent>(equivalent));

    auto result = std::vector<T, A>();
    result.resize(vec.size());

    auto current = std::begin(vec);
    while (current != std::end(vec))
    {
        if (seen.insert(*current).second)
        {
            result.push_back(*current);
        }
    }
    return result;
}

Наконец, пересмотр первого решения и рефакторинг на подзадачи (я ничего не могу с собой поделать):

// in-place de-duplication of sequence, similar interface to remove_if
template<class Iter, class Equivalent>
Iter inplace_deduplicate_sequence(Iter first, Iter last, Equivalent&& equivalent)
{
    while (first != last)
    {
        // define a predicate which checks for equivalence to current
        using value_type = typename std::iterator_traits<Iter>::value_type;
        auto same = [&](value_type const& x) -> bool
        {
            return equivalent(*first, x);
        };

        // move non-equivalent items to end of sequence
        // return new 'end of valid sequence'
        last = std::remove_if (std::next(first), last, same);
    }
    return last;
}

// in-place de-duplication on while vector, including container truncation    
template<class T, class A, class Equivalent>
void inplace_deduplicate(std::vector<T, A>& vec, Equivalent&& equivalent)
{
    vec.erase(inplace_deduplicate_sequence(vec.begin(), 
                                           vec.end(), 
                                           std::forward<Equivalent>(equivalent)), 
              vec.end());
}

// non-destructive version   
template<class T, class A, class Equivalent>
auto deduplicated2(std::vector<T, A> vec, Equivalent&& equivalent) -> std::vector<T, A>
{
    inplace_deduplicate(vec, std::forward<Equivalent>(equivalent));
    return vec;
}

Вот способ, в котором есть только один очень простой цикл:

Сначала определите наш класс, который я назову A вместо T, потому что T обычно используется для шаблонов:

class A{
public:
    explicit A(int _i) : i(_i){};
    int get() const{return i;}
private:
    int i;
};

А затем наша функция equivalent просто сравнивает целые числа на предмет равенства:

bool equivalent(A const& a, A const& b){return a.get() == b.get();}

Далее я определю функцию фильтрации.

Идея здесь состоит в том, чтобы воспользоваться преимуществом std::remove, чтобы эффективно выполнять цикл и стирание для нас (обычно он меняет местами элементы до конца, чтобы вы не смещали вектор для каждого удаления).

Мы начинаем с удаления всего, что соответствует первому элементу, затем удаляем все, что соответствует второму элементу (что теперь гарантировано! = Первому элементу) и так далее.

std::vector<A> filter_all_but_one_for_each_set_of_equivalent_A(std::vector<A> as) {
    for(size_t i = 1; i < as.size(); ++i){
       as.erase(std::remove_if (as.begin() + i, as.end(), [&as, i](const A& next){return equivalent(as[i-1], next);}), as.end());
    }
    return as;
}

Демо

Обновлено: как сказал Ричард Ходжес, можно отложить любое стирание до самого конца. Хотя я не мог сделать это так красиво:

std::vector<A> filter_all_but_one_for_each_set_of_equivalent_A(std::vector<A> as) {
    auto end = as.end();
    for(size_t i = 1; i < std::distance(as.begin(), end); ++i){
       end = std::remove_if (as.begin() + i, end, [&as, i](const A& next){return equivalent(as[i-1], next);});
    }
    as.erase(end, as.end());
    return as;
}

Демо 2

Вы можете попробовать это. Хитрость здесь в том, чтобы получить индекс внутри предиката.

std::vector<T> output; 
std::copy_if (
    input.begin(), input.end(),
    std::back_inserter(output),
    [&](const T& x) {
        size_t index = &x - &input[0];
        return find_if (
            input.begin(), input.begin() + index, x,
            [&x](const T& y) {
                return equivalent(x, y);
            }) == input.begin() + index;
    });

Поскольку производительность не является проблемой, вы можете использовать std::accumulate для сканирования элементов и добавления их в вектор аккумулятора xs, если это еще не сделано. эквивалентный элемент в xs.

При этом вам вообще не нужны рукописные необработанные циклы.

std::vector<A> filter_all_but_one_for_each_set_of_equivalent_A(std::vector<A> as) {       
    return std::accumulate(as.begin(), as.end(), 
                           std::vector<A>{}, [](std::vector<A> xs, A const& x) {
                               if ( std::find_if (xs.begin(), xs.end(), [x](A const& y) {return equivalent(x,y);}) == xs.end() ) {
                                   xs.push_back(x);
                               }

                               return xs;
                           });
}

С двумя вспомогательными функциями это становится действительно читаемым:

bool contains_equivalent(std::vector<A> const& xs, A const& x) {
    return std::find_if (xs.begin(), xs.end(), 
                        [x](A const& y) {return equivalent(x,y);}) != xs.end();
};

std::vector<A> push_back_if (std::vector<A> xs, A const& x) {
        if ( !contains_equivalent(xs, x) ) {
            xs.push_back(x);
        }

        return xs;
    };

Сама функция - это просто вызов std::accumulate:

std::vector<A> filter_all_but_one_for_each_set_of_equivalent_A(std::vector<A> as) {       
    return std::accumulate(as.begin(), as.end(), std::vector<A>{}, push_back_if);
}

Я изменил пример кода AndyG предложенной функцией.

Как определено выше, std::accumulate вызывает push_back_if с копией аккумуляторной переменной, и возвращаемое значение снова присваивается аккумулятору перемещением. Это очень неэффективно, но его можно оптимизировать, изменив push_back_if так, чтобы он принимал ссылку, чтобы вектор изменялся на месте. Начальное значение необходимо передать как обертку ссылки с std::ref, чтобы исключить оставшиеся копии.

std::vector<A>& push_back_if (std::vector<A>& xs, A const& x) {
        if ( !contains_equivalent(xs, x) ) {
            xs.push_back(x);
        }

        return xs;
    };

std::vector<A> filter_all_but_one_for_each_set_of_equivalent_A(std::vector<A> const& as) {       
    std::vector<A> acc;
    return std::accumulate(as.begin(), as.end(), std::ref(acc), push_back_if);
}

В примере видно, что конструктор копирования практически полностью исключен.