Як ефективно очистити чергу :: std ::?

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

Як я ефективно реалізую чіткий метод для класу 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 (розмір черги) . Методи , якими користується Девід Родрігес , анон мають однакову складність: за посиланням STL, operator =має складність O (розмір черги) . IMHO це тому, що кожен елемент черги зарезервований окремо і не виділяється в одному великому блоці пам'яті, як у векторному. Отже, щоб очистити всю пам'ять, ми повинні видалити кожен елемент окремо. Тож найпростіший спосіб очищення 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();
    }
};

Можливо, ваша реалізація також дозволяє об'єкту черги (тут 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';
}