priority_queue

I'm looking to create a priority_queue with the vector created in main() using B::weight to order the queue. How might I go about doing that?

Code:

---

#include <vector>
#include <string>

template <typename T>
class A
{
public:
        class B
        {
        private:
                B()
                {
                        weight = 0;
                }
                T data;
                int weight;
                friend class A;
        public:
                int get_weight()
                {
                        return weight;
                }
               
                bool operator==(const B& rhs) const
                {
                        return (*this).weight == rhs.weight;
                }

                bool operator<(const B& rhs) const
                {
                        return (*this).weight < rhs.weight;
                }

                bool operator>(const B& rhs) const
                {
                        return (*this).weight > rhs.weight;
                }
        };
        A() {}
        virtual ~A() {}
        B* create_B(T data, int weight = 0);
};

template <typename T>
typename A<T>::B* A<T>::create_B(T data, int weight = 0)
{
        B* new_B = new B;
        new_B->data = data;
        new_B->weight = weight;
        return new_B;
}

int main()
{
        A<std::string> myA;
        std::vector<A<std::string>::B*> stuff;
        stuff.push_back(myA.create_B("string1", 1));
        stuff.push_back(myA.create_B("string2", 2));

        return 0;
}

---

It looks like operator< is already correctly defined so you can #include <queue> and use a std::priority_queue<A<std::string>::B>.

That works great, but I need the queue to hold type B*, not B, so:

Code:

---

std::priority_queue<A<std::string>::B*>

---

The problem is, I still need it to sort using operator< (or B::weight). How would I go about doing such a thing?

make a wrapper class perhaps?

Or write a custom sort function object that sorts objects of type B* by referring to the objects to which they point.

Quote:

---

Originally Posted by tabstop

Or write a custom sort function object that sorts objects of type B* by referring to the objects to which they point.

---

I'm assuming, then, that I couldn't convince std::sort() to do the job on a vector of B*?

Of course, you can. But remember what sort looks like:

Code:

---

void sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp );

---

You need to tell sort when things are less than other things.