Come posso cancellare la coda std :: efficiente?

Sto usando std :: queue per implementare la classe JobQueue. (Fondamentalmente questa classe elabora ogni lavoro in modo FIFO). In uno scenario, desidero cancellare la coda in una sola volta (eliminare tutti i lavori dalla coda). Non vedo alcun metodo chiaro disponibile nella classe std :: queue.

Come posso implementare in modo efficiente il metodo clear per la classe JobQueue?

Ho una semplice soluzione di scoppiare in un ciclo ma sto cercando modi migliori.

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

Un linguaggio comune per cancellare i contenitori standard è scambiare con una versione vuota del contenitore:

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

È anche l'unico modo per cancellare effettivamente la memoria contenuta in alcuni contenitori (std :: vector)

Sì, un po 'un malfunzionamento della classe di coda, IMHO. Questo è ciò che faccio:

#include <queue>
using namespace std;;

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

L'autore dell'argomento ha chiesto come cancellare la coda "in modo efficiente", quindi presumo che voglia una maggiore complessità rispetto alla O lineare (dimensione della coda) . I metodi serviti da David Rodriguez , anon hanno la stessa complessità: secondo il riferimento STL, operator =ha la complessità O (dimensione della coda) . IMHO è perché ogni elemento della coda è riservato separatamente e non è allocato in un grande blocco di memoria, come nel vettore. Quindi, per cancellare tutta la memoria, dobbiamo eliminare ogni elemento separatamente. Quindi il modo più semplice per cancellare std::queueè una riga:

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

Apparentemente, ci sono due modi più ovvi per cancellare std::queue: scambiare con oggetto vuoto e assegnazione a oggetto vuoto.

Suggerirei di usare il compito perché è semplicemente più veloce, più leggibile e inequivocabile.

Ho misurato le prestazioni usando il seguente semplice codice e ho scoperto che lo scambio nella versione C ++ 03 funziona più lentamente del 70-80% rispetto all'assegnazione a un oggetto vuoto. In C ++ 11, tuttavia, non vi sono differenze nelle prestazioni. Comunque, andrei con un incarico.

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

In C ++ 11 puoi cancellare la coda in questo modo:

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

È possibile creare una classe che eredita dalla coda e cancellare direttamente il contenitore sottostante. Questo è molto efficiente.

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

Forse la tua implementazione consente anche al tuo oggetto Queue (qui JobQueue) di ereditare std::queue<Job>invece di avere la coda come variabile membro. In questo modo avresti accesso diretto alle c.clear()funzioni dei tuoi membri.

Supponendo che tu m_Queuecontenga interi:

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

Altrimenti, se contiene ad esempio puntatori a Joboggetti, allora:

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

In questo modo si scambia una coda vuota con la propria m_Queue, quindi m_Queuediventa vuota.

Preferirei non fare affidamento swap()o impostare la coda su un oggetto coda appena creato, perché gli elementi della coda non vengono distrutti correttamente. La chiamata pop()richiama il distruttore per il rispettivo oggetto elemento. Questo potrebbe non essere un problema nelle <int>code ma potrebbe avere effetti collaterali sulle code contenenti oggetti.

Pertanto un loop con while(!queue.empty()) queue.pop();sembra purtroppo essere la soluzione più efficiente almeno per le code contenenti oggetti se si desidera prevenire possibili effetti collaterali.

Faccio questo (usando C ++ 14):

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

In questo modo è utile se si dispone di un tipo di coda non banale per il quale non si desidera creare un alias / typedef. Mi assicuro sempre di lasciare un commento su questo utilizzo, tuttavia, per spiegare ai programmatori ignari / manutentori che questo non è pazzo, e fatto al posto di un clear()metodo reale .

L'uso di a unique_ptrpotrebbe essere OK.
Quindi reimpostarlo per ottenere una coda vuota e rilasciare la memoria della prima coda. Quanto alla complessità? Non ne sono sicuro, ma suppongo sia O (1).

Codice possibile:

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

Un'altra opzione è quella di utilizzare un semplice trucco per ottenere il contenitore sottostante std::queue::ce chiamarlo clear. Questo membro deve essere presente std::queuesecondo lo standard, ma purtroppo lo è protected. L'hack qui è stato preso da questa risposta .

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