布尔运算符重载不起作用

Question

Code sample:

#include <queue>
#include <vector>

using namespace std;

class Cell
{
public:
    int totalCost = 0;
};

class Helper
{
public:
    struct Comparator
    {
        bool operator()(Cell const *lfs, Cell const *rhs)
        {
            return lfs->totalCost < rhs->totalCost;
        }
    };
};

priority_queue<Cell*, vector<Cell*>, Helper::Comparator> path;

void function(Cell* cell)
    {
        cell->totalCost += rand() % 1000;
        path.push(cell);
    }

    int main()
    {
        Helper help;

        Cell first;
        Cell second;
        Cell third;
        Cell fourth;
        Cell fifth;

        Cell* firstPtr = &first;
        Cell* secondPtr = &second;
        Cell* thirdPtr = &third;
        Cell* fourthPtr = &fourth;
        Cell* fifthPtr = &fifth;



        function(firstPtr);
        function(secondPtr);
        function(thirdPtr);
        function(fourthPtr);
        function(fifthPtr);

        return 0;
    }

Debugger snip:

I am making a priority queue and I have tried overloading the () operator but for some reason it is not working at all (as seen in the debugger).

I have a feeling that something is wrong with the pointers but I can't figure out exactly what.

Answer 1

I don't see a problem in your code. Except that you forget to initialize the random numbers generator.

#include <iostream>
#include <queue>
#include <vector>
#include <cstdlib>

using namespace std;

class Cell
{
public:
    int totalCost = 0;
};

class Helper
{
public:
    struct Comparator
    {
        bool operator()(Cell const *lfs, Cell const *rhs)
        {
            return lfs->totalCost < rhs->totalCost;
        }
    };
};

priority_queue<Cell*, vector<Cell*>, Helper::Comparator> path;

void function(Cell* cell)
{
    cell->totalCost += rand() % 1000;
    path.push(cell);
}

int main()
{
    srand(time(0));
    Helper help;

    Cell first;
    Cell second;
    Cell third;
    Cell fourth;
    Cell fifth;

    Cell* firstPtr = &first;
    Cell* secondPtr = &second;
    Cell* thirdPtr = &third;
    Cell* fourthPtr = &fourth;
    Cell* fifthPtr = &fifth;

    function(firstPtr);
    function(secondPtr);
    function(thirdPtr);
    function(fourthPtr);
    function(fifthPtr);

for(;path.size();path.pop()) std::cout << path.top()->totalCost <<"\n";

    return 0;
}

It outputs:

luk32@debianvm:~/projects/tests$ ./a.out 
896
725
370
200
130
luk32@debianvm:~/projects/tests$ ./a.out 
699
672
285
250
208
luk32@debianvm:~/projects/tests$ ./a.out 
772
582
388
223
153
luk32@debianvm:~/projects/tests$ ./a.out 
869
807
670
642
182

Which is expected. Maybe you get confused because it does not sort items. But it does not have to. Only the first (top) one has to be grater than all others (according to the comparator). Rest of elements do not follow the n > n+1 . It 's becasue priority qeue is implemented on a heap. It can operate faster this way. as inserting elements takes O(log n) time. Keeping all elements sorted would require O(n) insert operation.

Answer 2

std::priority_queue is implemented over a heap, which comes with a slightly counter-intuitive side-effect because it's not using a "min heap", so the items are ordered from highest to lowest .

In a nutshell, you have your comparison operator the wrong way around -- if you want your priority queue to be in descending order, you need to test rhs < lhs rather than the other way around.

#include <queue>
#include <vector>
#include <iostream>

struct Cell
{
    int m_totalCost;
    Cell(int totalCost=0) : m_totalCost(totalCost) {}

    struct PriorityCompare
    {
        bool operator()(Cell const* lhs, const Cell* rhs) const
        {
            return rhs->m_totalCost < lhs->m_totalCost;
        }
    };
};

std::priority_queue<Cell*, std::vector<Cell*>, Cell::PriorityCompare> g_path;

int main()
{
    Cell first(rand() % 1000);
    Cell second(rand() % 1000);
    Cell third(rand() % 1000);
    Cell fourth(rand() % 1000);
    Cell fifth(rand() % 1000);

    g_path.push(&first);
    g_path.push(&second);
    g_path.push(&third);
    g_path.push(&fourth);
    g_path.push(&fifth);

    while (g_path.empty() == false) {
        Cell* cell = g_path.top();
        g_path.pop();
        std::cout << cell->m_totalCost << "\n";
    }
    return 0;
}

Live demo: http://ideone.com/BEjt4R outputs

383
777
793
886
915

---- ADDENDUM ----

Remember that the underlying std::vector is being used to implement a heap , so the items are not going to appear in-order in the vector when viewed thru the debugger.