¿Cómo borro la cola std :: de manera eficiente?

Estoy usando std :: queue para implementar la clase JobQueue. (Básicamente, esta clase procesa cada trabajo de manera FIFO). En un escenario, quiero borrar la cola de una vez (eliminar todos los trabajos de la cola). No veo ningún método claro disponible en la clase std :: queue.

¿Cómo implemento eficientemente el método claro para la clase JobQueue?

Tengo una solución simple de aparecer en un bucle pero estoy buscando mejores formas.

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

Un modismo común para borrar contenedores estándar es intercambiar con una versión vacía del contenedor:

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

También es la única forma de borrar realmente la memoria contenida en algunos contenedores (std :: vector)

Sí, una mala característica de la clase de cola, en mi humilde opinión. Esto es lo que hago:

#include <queue>
using namespace std;;

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

El autor del tema preguntó cómo borrar la cola "eficientemente", por lo que supongo que quiere una mayor complejidad que el O lineal (tamaño de la cola) . Los métodos servidos por David Rodríguez , anon tienen la misma complejidad: de acuerdo con la referencia de STL, operator =tiene complejidad O (tamaño de la cola) . En mi humilde opinión es porque cada elemento de la cola se reserva por separado y no se asigna en un gran bloque de memoria, como en el vector. Entonces, para borrar toda la memoria, tenemos que eliminar cada elemento por separado. Entonces, la forma más directa de despejar std::queuees una línea:

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

Aparentemente, hay dos formas más obvias de borrar std::queue: intercambiar con objeto vacío y asignar a objeto vacío.

Sugeriría usar la asignación porque es simplemente más rápida, más legible y sin ambigüedades.

Medí el rendimiento usando el siguiente código simple y descubrí que el intercambio en la versión C ++ 03 funciona un 70-80% más lento que la asignación a un objeto vacío. Sin embargo, en C ++ 11 no hay diferencia en el rendimiento. De todos modos, iría con la asignación.

#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;
}

En C ++ 11 puede borrar la cola haciendo esto:

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

Puede crear una clase que herede de la cola y borrar el contenedor subyacente directamente. Esto es muy eficiente.

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

Tal vez su implementación también permita que su objeto Queue (aquí JobQueue) herede en std::queue<Job>lugar de tener la cola como una variable miembro. De esta manera, tendría acceso directo a c.clear()sus funciones de miembro.

Suponiendo que m_Queuecontiene enteros:

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

De lo contrario, si contiene, por ejemplo, punteros a Jobobjetos, entonces:

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

De esta manera, intercambia una cola vacía con su m_Queue, por lo tanto, m_Queuequeda vacía.

Prefiero no confiar swap()o configurar la cola en un objeto de cola recién creado, porque los elementos de la cola no se destruyen correctamente. Llamar pop()invoca al destructor para el objeto del elemento respectivo. Esto podría no ser un problema en las <int>colas, pero podría tener efectos secundarios en las colas que contienen objetos.

Por lo tanto, un bucle con while(!queue.empty()) queue.pop();parece ser, por desgracia, la solución más eficiente, al menos para las colas que contienen objetos si desea evitar posibles efectos secundarios.

Hago esto (usando C ++ 14):

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

Esta forma es útil si tiene un tipo de cola no trivial para el que no desea construir un alias / typedef. Sin embargo, siempre me aseguro de dejar un comentario sobre este uso para explicar a los programadores desprevenidos / de mantenimiento que esto no es una locura y que se realiza en lugar de un clear()método real .

Usar un unique_ptrpodría estar bien.
Luego lo reinicia para obtener una cola vacía y libera la memoria de la primera cola. ¿En cuanto a la complejidad? No estoy seguro, pero supongo que es O (1).

Código posible:

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

Otra opción es usar un truco simple para obtener el contenedor subyacente std::queue::cy llamarlo clear. Este miembro debe estar presente std::queuesegún el estándar, pero desafortunadamente está presente protected. El truco aquí fue tomado de esta respuesta .

#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';
}