C ++ priority_queue pop（）和top（）差异

Question

I'm having a hard time understanding why a priority_queue pop() call is not removing the top() element. The priority queue has a custom comparison structure so that lower numbers have higher priority (and therefore should be retrieved with top()).

The debugging text (below) shows the top() element remains the same even after a pop().

Even if we make the assumption that the comparison structure is somehow wrong, top() should change after pop(), right? What else can I look at to understand why this is happening. The priority_queue code itself is a little inscrutable to me at the moment...

Note that this behavior is not consistent. There are other times when top() changes after a pop().

Any ideas? Thanks!

Debugging text (edited with top() shown before push():

size BEFORE push(): 1 TOP: [1488994840.745965281:0106996627] APPENDING: [1488994840.746157190:0106996627]
size  AFTER push(): 2 TOP: [1488994840.745965281:0106996627]
size BEFORE  pop(): 2 TOP: [1488994840.745965281:0106996627]
size  AFTER  pop(): 1 TOP: [1488994840.745965281:0106996627] // <- same top()!!

Where I push() to the priority_queue:

void Replica::appendPrepareOK(const PrepareOK &prepareOK) {
    PendingPrepare tmpPrepareOK = prepareOK;

    lock_guard<mutex> lck (this->lockPendingPrepare);

    this->logprint(3, "size BEFORE push(): " + to_string(this->pendingPrepare.size()) + " APPENDING: " + to_string(tmpPrepareOK));

    this->pendingPrepare.push(tmpPrepareOK);

    this->logprint(3, "size  AFTER push(): " + to_string(this->pendingPrepare.size()) + " TOP: " + to_string(this->pendingPrepare.top()));
}

Where I pop() from the priority_queue:

void Replica::sendPendingCmds() {
    ClockCommand *prepareCmd = NULL;
    PrepareOK *prepareOKCmd = NULL;
    Broadcast *broadcastCmd = NULL;

    {
        lock_guard<mutex> lck(this->lockPendingPrepare);

        if (! this->pendingPrepare.empty()) {
            this->logprint(3, "size BEFORE pop(): " + to_string(this->pendingPrepare.size()) + " TOP: " + to_string(this->pendingPrepare.top()));

            PendingPrepare firstCommand = this->pendingPrepare.top();
            this->pendingPrepare.pop();

            if (! this->pendingPrepare.empty()) {
                this->logprint(3, "size  AFTER pop(): " + to_string(this->pendingPrepare.size()) + " TOP: " + to_string(this->pendingPrepare.top()));
            }
            else {
                this->logprint(3, "size  AFTER pop(): " + to_string(this->pendingPrepare.size()));
            }

Definition of the priority_queue:

typedef priority_queue<PendingPrepare, deque<PendingPrepare>, PendCompare> pendQueue;

Custom PendCompare comparison class:

class PendCompare {
public:
    bool operator() (const PendingPrepare &a, const PendingPrepare &b) const {
        if (a.prepareOK != NULL) {
            if (b.prepareOK != NULL) { return a.prepareOK->tsOK > b.prepareOK->tsOK; }
            else if (b.prepare != NULL) { return a.prepareOK->tsOK > b.prepare->ts; }
        }
        else if (a.prepare != NULL) {
            if (b.prepareOK != NULL) { return a.prepare->ts > b.prepareOK->tsOK; }
            else if (b.prepare != NULL) { return a.prepare->ts > b.prepare->ts; }
        }

        return false;
    }
};

Relevant parts of the PendingPrepare struct:

struct PendingPrepare {
    ClockCommand* prepare = NULL;
    PrepareOK* prepareOK = NULL;

    void operator=(const PrepareOK &b) {
        this->prepareOK = new PrepareOK(b);
    }
};

Answer 1

Thanks to everyone for your assistance. Actually looking at the PendingPrepare contents solved the problem. I made the terrible assumption that only one of the pointers would be instantiated at a time, when there were occasions when both were instantiated, confusing the PendCompare comparison class.

Better copy constructors that deleted and NULLed the other pointer to avoid multiple instantiations solved the problem.