C ++中堆类的多态性

Question

Let's say I have a Rectangle class like so:

class Rectangle {
public:
    double width;
    double height;
}

Now I wish to store two possibly different lists of Rectangles as heaps, except that the first heap should be based on width and the second on height . Also, I wish to use the stl's make_heap function to heapify. Ideally, I should be able to call .heapify() on a heap, and based on the class that it belongs to, the heap in question should heapify itself by passing the correct comparison function to make_heap , perhaps using dynamic dispatch. What I have is the following:

class Heap {
public:
    vector<Rectangle> data;
    virtual bool comp(Rectangle a, Rectangle b);
    void heapify() { make_heap(data.begin(), data.end(), comp); }
    // other methods that make use of comp directly
}

class WidthHeap : public Heap {
    bool comp(Rectangle a, Rectangle b); // compares by width
}

class HeightHeap : public Heap {
    bool comp(Rectangle a, Rectangle b); // compares by height
}

This is all wrong because I guess I just don't understand functions in C++, which is why I would like your help.

Answer 1

Because comp is a member function pointer, it cannot be called without passing this . You need to bind this to it:

std::make_heap(data.begin(), data.end(), std::bind(&Heap::comp, this, _1, _2));

std::bind can be found in the <functional> header in C++11, and also available as std::tr1::bind in <tr1/functional> using TR1. If you can't use TR1 or C++11, there's a Boost library for it.

Demo: http://ideone.com/5zhmg

Answer 2

Apart from binding, another solution is simply to ask for a pointer to function to be passed to the constructor of Heap .

// C++03
typedef bool (*CompType)(Rectangle const&, Rectangle const&);

// C++11 (to allow for lambdas and predicates)
typedef std::function<bool(Rectangle const&, Rectangle const&)> CompType;

And then:

class Heap {
public:
  explicit Heap(CompType cmp): cmp(cmp) {}

  void heapify() {
    std::make_heap(data.begin(), data.end(), cmp);
  }

private:
  CompType cmp;
  std::vector<Rectangle> data;
}; // class Heap

What is interesting, is that you can even go further, and actually keep both orders at once with a little imagination.

class Heap {
public:
  Heap():
    byLength([](Rectangle const& l, Rectangle const& r) {
      return l.length < r.length; }),
    byWidth[](Rectangle const& l, Rectangle const& r) {
      return l.width < r.width; }),
  {}

  void heapify() {
    std::make_heap(data.begin(), data.end(), byLength);
    std::make_heap(ref.begin(), ref.end(),
      [](Rectangle const* l, Rectangle const* r) {
        return byWidth(*l, *r);
      });
  }

private:
  CompType byLength;
  CompType byWidth;
  std::vector<Rectangle> data;
  std::vector<Rectangle*> ref;
}; // class Heap

Although... it's probably a little overkill ;)

Answer 3

You are passing a member function. Member functions have a this pointer. Where should the make_heap function get that from?

Specifically, pointer to member functions are invoked with the following syntax (for an invented class X ):

X* obj_ptr; // initialize somewhere
typedef void (X::*mem_ptr)();
mem_ptr mem_fun = &X::some_invented_function;
(obj_ptr->*mem_fun)(); // extra parens needed

The obj_ptr is what the make_heap function would be missing. You somehow need to provide it, and the easiest way is probably through a lambda in C++11:

std::make_heap(data.begin(), data.end(),
    [this](Rectangle r1, Rectangle r2){
      return comp(r1,r2);
    });

Or maybe even std::bind :

#include <functional>

using std::placeholders;
std::make_heap(data.begin(), data.end(), std::bind(&X::comp, this, _1, _2));

If you don't have access to these C++11 functionalities, please resort to Boost.Bind .