Reversing the content of a set in C++ - c++

Question

I want to reverse the contents of a std::set(Not just iterating theough it in reverse, but reversing the contents iteslf). I found that std::set takes the compare as a function object for its constructor. Hence I came up with the following code to do the same:
#include <set>
using namespace std;
struct Comparator
{
Comparator(bool g) : m_g(g){}
bool operator()(int i1, int i2) const
{
if(m_g)
{
return i1>i2;
}
return i1<i2;
}
bool m_g;
};
int main(int argc, char** argv)
{
Comparator l(false);
set<int,Comparator> a(l);
a.insert(1);
a.insert(2);
a.insert(3);
Comparator g(true);
set<int,Comparator> b(g);
copy(a.begin(), a.end(), inserter(b, b.begin()));
a = b;
return 0;
}
This seems to work in VC9. But is this code correct? My doubt arises due to the fact my Comparator has state associated with it. Are comparators are allowed to have states?

Answer 1

Yes, that's legal. Consider that if the comparator was not allowed to have state, there would be no point in allowing you to pass a comparator as a constructor parameter. :)
As long as the comparator provides a strict weak ordering, it's fine (which, among other things, means that it has to be consistent. You can't change the state of it halfway through, so that it orders elements differently)

Answer 2

It's fine, but it's needlessly complex.
You can just use std::less (the default value for that template parameter!) or std::greater from the standard library. They are provided by <functional>.

Answer 3

A more generic solution. boost::assign and c++11 just for convenience (and the funny auto reverse)
# include <iostream>
# include <set>
# include <boost/assign.hpp>
using namespace boost::assign;
template <typename CL , typename Pred>
struct revPred {
revPred (Pred pred) : pred_(pred) {}
bool operator()(const CL & a, const CL& b)
{
return pred_(b,a);
}
Pred pred_;
};
template <typename CL , typename Pred, typename alloc>
inline
std::set<CL,revPred<CL,Pred>,alloc> reverseSet(const std::set<CL,Pred,alloc> & set) {
std::set<CL,revPred<CL,Pred>,alloc> res(revPred<CL,Pred>(set.key_comp()));
std::copy(set.begin(), set.end(), std::inserter(res, res.begin()));
return res;
}
int main()
{
std::set<int> s; s += 0 , 1 , 2 , 3;
std::for_each(s.begin(), s.end(), [](int x) { std::cout << x << " "; });
std::cout << std::endl;
auto reverse = reverseSet(s);
std::for_each(reverse.begin(), reverse.end(), [](int x) { std::cout << x << " "; });
std::cout << std::endl;
return 0;
}

Answer 4

There is nothing wrong with your code.
And there is nothing wrong with comparators having state.

Answer 5

This is ok since your comparison doesn't change dynamically and it does provide strict weak ordering.
However, if you're doing this so that the type of the set is the same even when the order changes, I might suggest an alternate idea. Instead of this comparison, you use two different set types with std::less and std::greater and use an iterator interface like the standard library does, rather than a container interface that depends on all the template parameters.
And finally as noted in the answer from #parapura rajkumar you should use the iterator pair constructor rather than std::copy:
// Assuming my other comments don't apply, modify as needed if they do:
Comparator g(true);
set<int, Comparator> b(a.rbegin(), a.rend(), g);

Answer 6

You don't need to provide a function object which maintains state. Just use a normal function and it should do the job. Pls. don't mind for the use of lambda. Used as a short cut to do the printing.
typedef bool (*Cmp)(int x, int y);
bool Compare(int x, int y)
{
return x < y;
}
bool CompareR(int x , int y)
{
return !Compare(x, y);
}
void SetReverse()
{
std::set<int, Cmp> s1(Compare);
s1.insert(1);
s1.insert(3);
s1.insert(2);
s1.insert(4);
std::for_each(s1.begin(), s1.end(), [](int x) { std::cout << x << "\n"; });
std::set<int, Cmp> s2(CompareR);
s2.insert(s1.begin(), s1.end());
std::for_each(s2.begin(), s2.end(), [](int x) { std::cout << x << "\n"; });
s1 = s2;
}

Answer 7

If you have a large enough set you have already paid the O(NlogN) penalty to make a balanced binary tree. A blind insert into the destination set, you will have to pay the penalty again.
Consider using one of these insert overload.
void insert ( InputIterator first, InputIterator last );
iterator insert ( iterator position, const value_type& x );
The range insert has linear complexity if [ first , last ) are sorted already.