STL heaps parameterized by comparator - c++

Question

I would like to write a wrapper class around STL heaps that allows the user to provide their own comparator. I would like to have the comparators be functors so that they may close over some state.
For example, consider maintaining a sorted list of 2D points. The sorting criterion is distance from a given point. I'd like to provide a default comparator that sorts based on distance from the origin, but also give the user the option to compare based on distance from an arbitrary point.
My problem is: I don't know how to properly structure the functor inheritance to make this work in a flexible manner. Here is the sorted points example to illustrate what I want:
struct Point {
int x, y;
Point(int xx, int yy) : x(xx), y(yy) {}
static float dist(const Point &a, const Point &b) {
const int dx = a.x - b.x, dy = a.y - b.y;
return sqrtf(dx*dx + dy*dy);
}
};
// Abstract Point comparison base class.
class Comparator {
public:
virtual bool operator()(const Point& lhs, const Point& rhs) = 0;
};
// Sorts Points according to distance from the origin.
class DefaultComparator : public Comparator {
public:
virtual bool operator()(const Point& lhs, const Point& rhs) {
const Point zero(0,0);
const float dl = Point::dist(zero, lhs), dr = Point::dist(zero, rhs);
return dl < dr;
}
};
// Sorts Points according to distance from a given Point.
class RelativeComparator : public Comparator {
public:
RelativeComparator(Point p) : _point(p) {}
virtual bool operator()(const Point& lhs, const Point& rhs) {
const float dl = Point::dist(_point, lhs), dr = Point::dist(_point, rhs);
return dl < dr;
}
private:
const Point _point;
};
class SortedPoints {
public:
SortedPoints(Comparator &comp) : _comp(comp) {}
void push(Point p) {
_points.push_back(p);
std::push_heap(_points.begin(), _points.end(), _comp);
}
bool pop(Point &p) {
if (_points.empty()) {
return false;
} else {
std::pop_heap(_points.begin(), _points.end(), _comp);
p = _points.back();
_points.pop_back();
return true;
}
}
private:
typedef std::vector<Point> PointList;
Comparator &_comp;
PointList _points;
};
int main() {
DefaultComparator defaultComp;
RelativeComparator relativeComp(Point(100,100));
SortedPoints list1 = SortedPoints(defaultComp);
SortedPoints list2 = SortedPoints(relativeComp);
Point p(0,0);
list1.push(Point(15,15));
list1.push(Point(13,13));
list1.push(Point(5,5));
printf("List one (relative to 0,0):\n");
while (list1.pop(p)) {
printf("%d,%d\n", p.x, p.y);
}
list2.push(Point(15,15));
list2.push(Point(13,13));
list2.push(Point(5,5));
printf("List two (relative to 100,100):\n");
while (list2.pop(p)) {
printf("%d,%d\n", p.x, p.y);
}
return 0;
}
Due to the way the inheritance is structured, I'm getting a compilation error when the STL heap implementation tries to instantiate a Comparator (because it's an abstract class). The precise error is:
sortedpoints.cpp: In member function ‘void SortedPoints::push(Point)’:
sortedpoints.cpp:51: error: cannot allocate an object of abstract type ‘Comparator’
sortedpoints.cpp:17: note: because the following virtual functions are pure within ‘Comparator’:
sortedpoints.cpp:19: note: virtual bool Comparator::operator()(const Point&, const Point&)
/usr/include/c++/4.2.1/bits/stl_heap.h: In function ‘void std::push_heap(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Point*, std::vector<Point, std::allocator<Point> > >, _Compare = Comparator]’:
sortedpoints.cpp:51: instantiated from here
/usr/include/c++/4.2.1/bits/stl_heap.h:203: error: cannot allocate an object of abstract type ‘Comparator’
sortedpoints.cpp:17: note: since type ‘Comparator’ has pure virtual functions
/usr/include/c++/4.2.1/bits/stl_heap.h: In function ‘void std::__adjust_heap(_RandomAccessIterator, _Distance, _Distance, _Tp) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Point*, std::vector<Point, std::allocator<Point> > >, _Distance = long int, _Tp = Point]’:
/usr/include/c++/4.2.1/bits/stl_heap.h:238: instantiated from ‘void std::__pop_heap(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Tp) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Point*, std::vector<Point, std::allocator<Point> > >, _Tp = Point]’
/usr/include/c++/4.2.1/bits/stl_heap.h:265: instantiated from ‘void std::pop_heap(_RandomAccessIterator, _RandomAccessIterator) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Point*, std::vector<Point, std::allocator<Point> > >]’
sortedpoints.cpp:58: instantiated from here
What is the proper way to accomplish this sort of task? If my Comparator inheritance strategy is a bad one, I'd like to know that too: this is just the first method I tried.

Answer 1

If you look at the documentation for push_heap, you'll see that it takes the comparator by value, so it's going to try to copy your Comparator object.
template <class RandomAccessIterator, class Compare>
void push_heap (RandomAccessIterator first, RandomAccessIterator last,
Compare comp);
Instead of holding a reference to the Comparator object in SortedPoints, you could create a std::function object that matched the Comparator function signature and pass that into push_heap (or boost::function if you're stuck on C++03).
For your code, you could try something like this:
class SortedPoints
{
public:
typedef std::function<bool (const Point& lhs, const Point& rhs)> MyComparator; // <-- Add this typedef
SortedPoints(MyComparator comp) : _comp(comp) {} // <-- Use MyComparator instead of Comparator&
void push(Point p) {
_points.push_back(p);
std::push_heap(_points.begin(), _points.end(), _comp);
}
bool pop(Point &p) {
if (_points.empty()) {
return false;
} else {
std::pop_heap(_points.begin(), _points.end());
p = _points.front();
_points.pop_back();
return true;
}
}
private:
typedef std::vector<Point> PointList;
MyComparator _comp; // <-- Use MyComparator instead of Comparator&
PointList _points;
};

Answer 2

I figured out a way to do what I want using regular OOP paradigms. Using the C++11 functional features suggested by #pzed is a good idea, however the rest of my codebase is not C++11 and I'd like to stick with consistent paradigms.
The strategy is to have the base Comparator class close over a subclass instance, and simply pass through the comparison to the subclass.
For example, the three classes from above become:
class Comparator {
public:
Comparator(Comparator &c) : _comparator(c) {}
virtual bool operator()(const Point& lhs, const Point& rhs) {
return _comparator(lhs, rhs);
}
private:
Comparator& _comparator;
};
// Sorts Points according to distance from the origin.
class DefaultComparator : public Comparator {
public:
DefaultComparator() : Comparator(*this) {}
virtual bool operator()(const Point& lhs, const Point& rhs) {
const Point zero(0,0);
const float dl = Point::dist(zero, lhs), dr = Point::dist(zero, rhs);
return dl < dr;
}
};
// Sorts Points according to distance from a given Point.
class RelativeComparator : public Comparator {
public:
RelativeComparator(Point p) : Comparator(*this), _point(p) {}
virtual bool operator()(const Point& lhs, const Point& rhs) {
const float dl = Point::dist(_point, lhs), dr = Point::dist(_point, rhs);
return dl < dr;
}
private:
const Point _point;
};
And the rest of the code stays the same, for example we can now do:
RelativeComparator relativeComp(Point(100,100));
SortedPoints list1 = SortedPoints(relativeComp);
as before, and it works.
Hopefully this isn't considered an abuse of inheritance.

Answer 3

I got this working by making 3 changes:
Removed the polymorphism in favor of templates
Added the comparator to the pop_heap call as well.
Added const to the operator ()
I get this:
// Sorts Points according to distance from the origin.
class DefaultComparator {
public:
virtual bool operator()(const Point& lhs, const Point& rhs) const {
const Point zero(0, 0);
const float dl = Point::dist(zero, lhs), dr = Point::dist(zero, rhs);
return dl < dr;
}
};
// Sorts Points according to distance from a given Point.
class RelativeComparator {
public:
RelativeComparator(Point p) : _point(p) {}
virtual bool operator()(const Point& lhs, const Point& rhs) const {
const float dl = Point::dist(_point, lhs), dr = Point::dist(_point, rhs);
return dl < dr;
}
private:
const Point _point;
};
template <class C>
class SortedPoints
{
public:
SortedPoints(C &comp) : _comp(comp) {}
void push(Point p) {
_points.push_back(p);
std::push_heap(_points.begin(), _points.end(), _comp);
}
bool pop(Point &p) {
if (_points.empty()) {
return false;
}
else {
std::pop_heap(_points.begin(), _points.end(), _comp);
p = _points.front();
_points.pop_back();
return true;
}
}
private:
typedef std::vector<Point> PointList;
C &_comp;
PointList _points;
};
int main()
{
DefaultComparator defaultComp;
RelativeComparator relativeComp(Point(100, 100));
SortedPoints<DefaultComparator> list1 = SortedPoints<DefaultComparator>(defaultComp);
Point p(0, 0);
list1.push(Point(15, 15));
list1.push(Point(13, 13));
list1.push(Point(5, 5));
printf("List one (relative to 0,0):\n");
while (list1.pop(p)) {
printf("%d,%d\n", p.x, p.y);
}
SortedPoints<RelativeComparator> list2 = SortedPoints<RelativeComparator>(relativeComp);
list2.push(Point(15, 15));
list2.push(Point(13, 13));
list2.push(Point(5, 5));
printf("List two (relative to 100,100):\n");
while (list2.pop(p)) {
printf("%d,%d\n", p.x, p.y);
}
return 0;
}