unique_copy元素值从map到vector

Question

I have a map<K, V> and I want to use unique_copy to put the values into a vector<V> . I tried this but it doesn't work:

#include <iostream>
#include <map>
#include <algorithm>
#include <vector>
#include <functional>
using namespace std;
using namespace placeholders;


int main() {
    map<std::string, int> mp;

    mp["1"] = 1;
    mp["2"] = 2;
    mp["3"] = 3;
    mp["4"] = 3;
    mp["5"] = 3;
    mp["6"] = 4;
    mp["7"] = 2;

    vector<int> vec;

    unique_copy( mp.begin(), mp.end(),
                 back_inserter(vec),
                 bind(&map<std::string, int>::value_type::second, _1) );


    for( auto& i : vec )
        cout<< i <<" ";
}

Expected output: 1 2 3 4 2

All google searches return ways to use transform but I need unique_copy . Is there any way to make this work?

Answer 1

There's no way to do this directly, because the value type of the map iterator and the vector iterator are not compatible. You really need a transform of some sort, or an iterator adaptor.

You could use boost::transform_iterator for this:

auto getValue = [](const std::map<std::string, int>::value_type &pair) { return pair.second; };

unique_copy(
  boost::make_transform_iterator(mp.begin(), getValue),
  boost::make_transform_iterator(mp.end(), getValue),
  back_inserter(vec)
);

If you cannot use Boost, you'll have to write such an iterator adaptor yourself:

template <class T_PairIterator>
struct SecondIterator
{
  typedef T_PairIterator PairIterator;
  typedef typename std::iterator_traits<PairIterator>::iterator_category iterator_category;
  typedef typename std::iterator_traits<PairIterator>::value_type::second_type value_type;
  typedef typename std::iterator_traits<PairIterator>::difference_type difference_type;
  typedef value_type *pointer;
  typedef value_type &reference;

  PairIterator it;

  SecondIterator() {}

  explicit SecondIterator(PairIterator it) : it(it) {}

  pointer operator-> () const { return &it->second; }

  reference operator* () const { return it->second; }

  SecondIterator& operator++ () { ++it; return *this; }

  SecondIterator operator++ (int) { SecondIterator ret(*this); ++it; return ret; }
};

template <class T>
bool operator== (const SecondIterator<T> &lhs, const SecondIterator<T> &rhs)
{ return lhs.it == rhs.it; }

template <class T>
bool operator!= (const SecondIterator<T> &lhs, const SecondIterator<T> &rhs)
{ return !(lhs == rhs); }

template <class T>
SecondIterator<T> makeSecondIterator(const T &it)
{ return SecondIterator<T>(it); }

You could then use it like this:

unique_copy(
  makeSecondIterator(mp.begin()),
  makeSecondIterator(mp.end()),
  back_inserter(vec)
);

Of course, the adaptor could be made a bit more generic (perhaps usable for first as well), and/or more encapsulated ( it needn't be public); it would also need proper handling for const-iterators. But the above should be enough to give you the idea.

Answer 2

As Vijay says in his comment, you could use a std::set instead of a vector (if you don't need the individual features of a vector, of course, like contiguous storage, custom ordering or random access). In this case the std::set::insert will already take care of removing duplicates and you can use std::transform in the way you tried:

std::set<int> set;
std::transform( mp.begin(), mp.end(), std::inserter(set),
                bind(&std::map<std::string, int>::value_type::second, _1) );

---

As to your modified question

std::set won't insert the value if it is already in the set but I don't want consecutive duplicates.

Well, in this case just do a normal copy (ie std::transform ) into the vector and do a std::unique afterwards, which will just remove all consecutive duplicates:

std::transform( mp.begin(), mp.end(), std::inserter(vec),
                bind(&std::map<std::string, int>::value_type::second, _1) );
vec.erase( std::unique(vec.begin(), vec.end()), vec.end() );

Answer 3

std::copy followed by vec.erase( std::unique( vec.begin(), vec.end() ), vec.end() ); will end up in the same place as unique_copy with a transform would. It may use extra memory in the middle (before removing redundant entries) but is pretty clean.

A manual copy is another option:

if(!src.empty()){
  auto* prev = &src.begin()->second;
  dest.push_back(*prev);
  for(auto it = std::next(src.begin()); it != sec.end(); ++it){
    if (it->second == *prev) continue;
    prev=&it->second;
    dest.push_back(*prev);
  }
}

with the note thay prev is technically redundant (use dest.back() instead of *prev except when push_back ing -- there use ->second ).