Access violation in custom comparator in priority queue

Question

I have an issue were a program of mine throws an access violation. Through debugging I found that for some reason the comparator-function is null. However I am not sure on why that is or how to fix it.

I created a minimum working example to reproduce the issue:

#include "Tryout.h"
#include <queue>

struct Event {
    uint64_t mv_timeout;
};

bool CompareEvents(const Event& a, const Event& b) {
    return a.mv_timeout < b.mv_timeout;
}

int main() {
    std::priority_queue<Event, std::vector<Event>, decltype(&CompareEvents)> mt_eventQueue;
    Event lo_event1{
        .mv_timeout = 1,
    };
    Event lo_event2{
        .mv_timeout = 2,
    };
    mt_eventQueue.push(lo_event1);
    mt_eventQueue.push(lo_event2);
    return 0;
}

When executing it crashes when adding the second event.

Exception thrown at 0x0000000000000000 in Tryout.exe: 0xC0000005: Access violation executing location 0x0000000000000000.

As mentioned it seems the comparing function is null, even tough I passed it via template.
What is going wrong here?

Vlad from Moscow · Accepted Answer · 2021-09-25T11:07:29.753

1

You need to specify the comparison function explicitly in the constructor

std::priority_queue<Event, std::vector<Event>, decltype(&CompareEvents)> mt_eventQueue( CompareEvents );

Otherwise the default argument will be used for the comparison function that will yield a null pointer.

The used constructor has the following declaration with default arguments

explicit priority_queue(const Compare& x = Compare(), Container&& = Container());

edited Sep 25 '21 at 11:07

answered Sep 25 '21 at 10:57

Vlad from Moscow

301,070
26
186
335

That was a simple solution - Thank you! – user2089648 Sep 25 '21 at 11:05

score 1 · Answer 2 · answered Sep 25 '21 at 11:02

The template argument for the comparator function only provides the function's type, you still need to supply an actual function matching that type to an instance of std::priority_queue (via its constructor).

If you define a less-than operator yourself, then you don't need to explicitly supply any other template arguments for std::priority_queue.

For example:

struct Event
{
    uint64_t mv_timeout;
};

bool operator<(const Event &a, const Event &b)
{
    return a.mv_timeout < b.mv_timeout;
}

int main()
{
    std::priority_queue<Event> mt_eventQueue;
    Event lo_event1{
        .mv_timeout = 1,
    };
    Event lo_event2{
        .mv_timeout = 2,
    };
    mt_eventQueue.push(lo_event1);
    mt_eventQueue.push(lo_event2);
    return 0;
}

score 1 · Answer 3 · answered Sep 25 '21 at 11:04

As far as your comparator function is not a functor, you should pass your comparator function in the constructor of std::priority:queue.

std::priority_queue<Event, std::vector<Event>, decltype(&CompareEvents)> mt_eventQueue(CompareEvents);

If your comparator was a something like this

struct CompareEvents
{
    bool operator()(const Event& a, const Event& b) {
        return a.mv_timeout < b.mv_timeout;
    }
}

You could have created the queue without specifying the functor, as far as it would be deduced by default constructor of CompareEvents,(as stated here).

std::priority_queue<Event, std::vector<Event>, CompareEvents> mt_eventQueue; //this works

Access violation in custom comparator in priority queue

3 Answers3