Как эффективно очистить очередь std :: queue?

Я использую std :: queue для реализации класса JobQueue. (В основном этот класс обрабатывает каждую работу в порядке FIFO). В одном сценарии я хочу очистить очередь за один раз (удалить все задания из очереди). Я не вижу четкого метода, доступного в классе std :: queue.

Как эффективно реализовать метод clear для класса JobQueue?

У меня есть одно простое решение выскочить в цикле, но я ищу лучшие способы.

//Clears the job queue
void JobQueue ::clearJobs()
 {
  // I want to avoid pop in a loop
    while (!m_Queue.empty())
    {
        m_Queue.pop();
    }
}

Распространенная идиома для очистки стандартных контейнеров - это замена пустой версией контейнера:

void clear( std::queue<int> &q )
{
   std::queue<int> empty;
   std::swap( q, empty );
}

Это также единственный способ очистки памяти, содержащейся в некоторых контейнерах (std :: vector).

Да - небольшая ошибка в классе очереди, ИМХО. Вот что я делаю:

#include <queue>
using namespace std;;

int main() {
    queue <int> q1;
    // stuff
    q1 = queue<int>();  
}

Автор темы спросил, как очистить очередь «эффективно», поэтому я предполагаю, что он хочет лучшей сложности, чем линейный O (размер очереди) . Методы , обслуживаемый Дэвид Родригес , Anon имеют одинаковую сложность: в соответствии со справочной STL, operator =имеет сложность O (очередь размера) . ИМХО, это потому, что каждый элемент очереди зарезервирован отдельно и не размещается в одном большом блоке памяти, как в векторе. Таким образом, чтобы очистить всю память, мы должны удалить каждый элемент отдельно. Таким образом, самый простой способ очистить std::queueэто одна строка:

while(!Q.empty()) Q.pop();

Очевидно, есть два наиболее очевидных способа очистки std::queue: замена пустого объекта и присвоение пустому объекту.

Я бы предложил использовать назначение, потому что оно просто быстрее, более читабельно и однозначно.

Я измерил производительность с помощью следующего простого кода и обнаружил, что подкачка в версии C ++ 03 работает на 70-80% медленнее, чем присвоение пустому объекту. Однако в C ++ 11 нет различий в производительности. Во всяком случае, я бы пошел с заданием.

#include <algorithm>
#include <ctime>
#include <iostream>
#include <queue>
#include <vector>

int main()
{
    std::cout << "Started" << std::endl;

    std::queue<int> q;

    for (int i = 0; i < 10000; ++i)
    {
        q.push(i);
    }

    std::vector<std::queue<int> > queues(10000, q);

    const std::clock_t begin = std::clock();

    for (std::vector<int>::size_type i = 0; i < queues.size(); ++i)
    {
        // OK in all versions
        queues[i] = std::queue<int>();

        // OK since C++11
        // std::queue<int>().swap(queues[i]);

        // OK before C++11 but slow
        // std::queue<int> empty;
        // std::swap(empty, queues[i]);
    }

    const double elapsed = double(clock() - begin) / CLOCKS_PER_SEC;

    std::cout << elapsed << std::endl;

    return 0;
}

В C ++ 11 вы можете очистить очередь, выполнив это:

std::queue<int> queue;
// ...
queue = {};

Вы можете создать класс, который наследует от очереди, и очистить базовый контейнер напрямую. Это очень эффективно.

template<class T>
class queue_clearable : public std::queue<T>
{
public:
    void clear()
    {
        c.clear();
    }
};

Возможно, ваша реализация также позволяет вашему объекту Queue (здесь JobQueue) наследовать std::queue<Job>вместо того, чтобы иметь очередь в качестве переменной-члена. Таким образом, у вас будет прямой доступ к c.clear()функциям вашего члена.

Предполагая, что ваш m_Queueсодержит целые числа:

std::queue<int>().swap(m_Queue)

В противном случае, если он содержит, например, указатели на Jobобъекты, то:

std::queue<Job*>().swap(m_Queue)

Таким образом, вы меняете пустую очередь на свою m_Queue, таким образом, m_Queueстановитесь пустыми.

Я бы предпочел не полагаться swap()или устанавливать очередь для вновь созданного объекта очереди, потому что элементы очереди не уничтожаются должным образом. Вызов pop()вызывает деструктор для соответствующего объекта элемента. Это может не быть проблемой в <int>очередях, но вполне может иметь побочные эффекты для очередей, содержащих объекты.

Поэтому while(!queue.empty()) queue.pop();, к сожалению, цикл с представляется наиболее эффективным решением, по крайней мере, для очередей, содержащих объекты, если вы хотите предотвратить возможные побочные эффекты.

Я делаю это (используя C ++ 14):

std::queue<int> myqueue;
myqueue = decltype(myqueue){};

Этот способ полезен, если у вас нетривиальный тип очереди, для которого вы не хотите создавать псевдоним / typedef. Тем не менее, я всегда оставляю комментарий об этом использовании, чтобы объяснить ничего не подозревающим программистам, что это не сумасшествие и сделано вместо реального clear()метода.

Использование unique_ptrможет быть в порядке.
Затем вы сбрасываете его, чтобы получить пустую очередь и освободить память первой очереди. Что касается сложности? Я не уверен - но думаю, это O (1).

Возможный код:

typedef queue<int> quint;

unique_ptr<quint> p(new quint);

// ...

p.reset(new quint);  // the old queue has been destroyed and you start afresh with an empty queue

Другой вариант - использовать простой хак, чтобы получить базовый контейнер std::queue::cи вызвать clearего. Этот участник должен присутствовать в std::queueсоответствии со стандартом, но к сожалению protected. Взлом здесь был взят из этого ответа .

#include <queue>

template<class ADAPTER>
typename ADAPTER::container_type& get_container(ADAPTER& a)
{
    struct hack : ADAPTER
    {
        static typename ADAPTER::container_type& get(ADAPTER& a)
        {
            return a .* &hack::c;
        }
    };
    return hack::get(a);
}

template<typename T, typename C>
void clear(std::queue<T,C>& q)
{
    get_container(q).clear();
}

#include <iostream>
int main()
{
    std::queue<int> q;
    q.push(3);
    q.push(5);
    std::cout << q.size() << '\n';
    clear(q);
    std::cout << q.size() << '\n';
}