Удалить эквивалентные пары из вектора пар при помощи стандартных алгоритмов

std::vector<std::pair<int,int> >

struct comp{
    bool operator()(std::pair<int,int> p1,std::pair<int,int> p2){
        return p1.first==p2.second && p1.second==p2.first;;
    }
};

#include <algorithm>
#include <utility>
#include <vector>
#include <functional>
 
typedef std::pair<int,int> pair;
 
struct trans : std::unary_function<pair, pair>
    {
    pair operator() (pair const & p)
        {
        return p.first < p.second ? p : std::make_pair<int,int>(p.second, p.first);
        }
    };
 
int main()
    {
 
    typedef std::vector<pair> vector;
 
    vector vec;
    // ...
 
    std::transform(vec.begin(), vec.end(), vec.begin(), trans());
    std::sort(vec.begin(), vec.end());
    vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
    }

        bool operator()(std::pair<int,int> p1,std::pair<int,int> p2){
                return p1.first==p2.second;//&& p1.second==p2.first;;
        }

typedef pair < int, int > elem;
...
bool comp_elem ( elem a, elem b ){
     return a.first==b.second && a.second==b.first;
}

#include <iostream>
#include <algorithm>
#include <utility>
#include <vector>
 
using namespace std;
 
#define NUM1 3
#define NUM2 8
typedef pair < int, int > elem;
 
//функция заполнения вектора
void fill_vec( vector < elem > &vec );
//функция печати вектора
void print_vec ( vector < elem > &vec );
 
int main() {
 
    vector < elem > my_vec ( 10 );
    //заполняем вектор
    fill_vec( my_vec );
    print_vec( my_vec );
 
    //сортируем вектор
    sort( my_vec.begin(), my_vec.end() );
    print_vec( my_vec );
 
    //сортируем так чтобы эквивалентные оказались рядом
    stable_sort( my_vec.begin(), my_vec.end() );
    print_vec( my_vec );
 
    //переносим уникальные элементы вначало вектора
    vector < elem >::iterator end_unique = unique( my_vec.begin(), my_vec.end() );
    print_vec( my_vec );
 
    //удаляем эквивалентные пары
    my_vec.erase( end_unique, my_vec.end() );
    print_vec( my_vec );
 
    return 0;
}
 
 
void fill_vec( vector < elem > &vec ){
    if (vec.size() == 0){
            cout << "Размер вектора равен 0! Невозможно заполнить!";
            return;
    }
 
    vector < elem >::iterator it = vec.begin();
        int n = 0;
        while ( it != vec.end() ){
            ++n % 2 ? (*it++ = make_pair( n, n )) : (*it++ = make_pair( NUM1 , NUM2 ));
        }
 
 
 
}
 
void print_vec ( vector < elem > &vec ){
 
    if (vec.size() == 0){
        cout << "Вектор пустой! Нечего печатать!";
        return;
    }
 
    vector < elem >::const_iterator it = vec.begin();
    while ( it != vec.end() ){
        cout << "( " << (*it).first << " " << (*it).second << " )  ";
        ++it;
    }
 
    cout << endl;
}

struct comp_for_sort{
    bool operator()(std::pair<int,int> p1,std::pair<int,int> p2){
        return std::min(p1.first, p1.second) < std::min(p2.first, p2.second);
    }
};

struct comp_for_sort{
    bool operator()(std::pair<int,int> p1,std::pair<int,int> p2){
        if (std::min(p1.first, p1.second) == std::min(p2.first, p2.second))
            return std::max(p1.first, p1.second) < std::max(p2.first, p2.second)
        return std::min(p1.first, p1.second) < std::min(p2.first, p2.second);
    }
};

std::for_each(vec.begin(), vec.end(),[=](const std::pair<int, int>& pair){ std::cout << pair.first << ", " << pair.second << std::endl;});

std::for_each(vec.begin(), vec.end(),[](const std::pair<int, int>& pair){ std::cout <<pair<<std::endl;});

struct pair_less : public
   std::binary_function<const std::pair<int, int> &,
                        const std::pair<int, int> &,
                        bool>
{
   bool operator ()( const std::pair<int, int> &a,
                     const std::pair<int, int> &b ) const
   {
      return ( std::min( a.first, a.second ) < std::min( b.first, b.second ) );
   }
};

std::pair

template <typename T1, typename T2>
 
bool operator <( const std::pair<T1, T2> &a, std::pair<T1, T2> &b )
{
   return ( ( a.first < b.first ) ||
              ( !( b.first < a.first ) && ( a.second < b.second ) ) );
}

template <typename T>
struct pair_less : public
   std::binary_function<std::pair<T, T>, std::pair<T, T>, bool>
{
   bool operator ()( const std::pair<T, T> &a,
                     const std::pair<T, T> &b ) const
   {
      return
      ( ( std::min( a.first, a.second ) < std::min( b.first, b.second ) ) ||
        ( !( std::min( b.first, b.second ) < std::min( a.first, a.second ) ) &&
          ( std::max( a.first, a.second ) < std::max( b.first, b.second ) ) );
   }
};

std::string s;
std::cout<<s<<std::endl;

std::operator<<(std::operator(std::cout,s),std::endl);

std::ostream& operator<<(std::ostream &os, const std::pair<int,int> &ob){
    return os<<ob.first<<" "<<ob.second;
}
 
int main() {
    std::vector<std::pair<int,int> >v;
    v.push_back(std::make_pair(10,20));
    v.push_back(std::make_pair(100,200));
    std::copy(v.begin(),v.end(),std::ostream_iterator<std::pair<int,int> >(std::cout,"\n"));
}

namespace std{
    std::ostream& operator<<(std::ostream &os, const std::pair<int,int> &ob){
        return os<<ob.first<<" "<<ob.second;
    }
}