std :: iteración de colas

Question

necesito iterar sobre std::queue. www.cplusplus.com dice:

  

Por defecto, si no se especifica ninguna clase de contenedor para una clase de cola particular, se utiliza el deque plantilla de clase contenedor estándar.

Así que puedo conseguir de alguna manera a deque subyacente de la cola y iterar sobre él?

Answer 1

Si necesita repetir un queue entonces necesita algo más que una cola. El punto de los adaptadores de contenedores estándar es proporcionar una interfaz mínima. Si lo que necesita hacer iteración así, ¿por qué no usar una doble cola (o lista) en lugar?

Answer 2

Aunque estoy de acuerdo con otros que el uso directo de un contenedor iterables es una solución preferida, quiero señalar que el estándar C ++ garantiza el apoyo suficiente para un do-it-yourself solución en caso de que lo deseen por cualquier razón.

A saber, se puede heredar de std::queue y utilizar su Container c; miembro protegido para tener acceso begin () y al final () del contenedor subyacente (siempre que tales métodos existan allí). Aquí hay un ejemplo que funciona en VS 2010 y probado con Ideone :

#include <queue>
#include <deque>
#include <iostream>

template<typename T, typename Container=std::deque<T> >
class iterable_queue : public std::queue<T,Container>
{
public:
    typedef typename Container::iterator iterator;
    typedef typename Container::const_iterator const_iterator;

    iterator begin() { return this->c.begin(); }
    iterator end() { return this->c.end(); }
    const_iterator begin() const { return this->c.begin(); }
    const_iterator end() const { return this->c.end(); }
};

int main() {
    iterable_queue<int> int_queue;
    for(int i=0; i<10; ++i)
        int_queue.push(i);
    for(auto it=int_queue.begin(); it!=int_queue.end();++it)
        std::cout << *it << "\n";
    return 0;
}

Answer 3

puede guardar la cola original a una cola temporal. Entonces sólo tiene que hacer su pop normales en la cola temporal que pasar por el original, por ejemplo:

queue tmp_q = original_q; //copy the original queue to the temporary queue

while (!tmp_q.empty())
{
    q_element = tmp_q.front();
    std::cout << q_element <<"\n";
    tmp_q.pop();
} 

Al final, la tmp_q estará vacía pero la cola original es intacto.

Answer 4

¿Por qué no hacer una copia de la cola que desee para repetir, y eliminar elementos uno a la vez, su impresión sobre la marcha? Si desea hacer más con los elementos como iterar, a continuación, una cola es la estructura de datos incorrecto.

Answer 5

Alexey Kukanov puede ser más eficiente, también puede iterar a través de una cola de una manera muy natural, haciendo estallar cada elemento de la parte delantera de la cola, a continuación, empujando a la parte posterior:

#include <iostream>
#include <queue>

using namespace std;

int main() {
    //populate queue
    queue<int> q;
    for (int i = 0; i < 10; ++i) q.push(i);

    // iterate through queue
    for (size_t i = 0; i < q.size(); ++i) {
        int elem = std::move(q.front());
        q.pop();
        elem *= elem;
        q.push(std::move(elem));
    }

    //print queue
    while (!q.empty()) {
        cout << q.front() << ' ';
        q.pop();
    }
}

salida:

0 1 4 9 16 25 36 49 64 81 

Answer 6

Si tiene que recorrer una cola ... cola no es el contenedor que necesita.
¿Por qué eligió una cola?
¿Por qué no te tomas un contenedor que se puede recorrer en iteración?

---

1.if a elegir una cola entonces usted dice que quiere envolver un recipiente en una interfaz de 'cola':     - delante     - espalda     - empujar     - pop     - ...

Si usted también quiere repetir, una cola tiene una interfaz incorrecta. Una cola es un adaptador que proporciona un subconjunto restringido del recipiente de origen

definición 2.El de una cola es un FIFO y, por definición, un FIFO no es iterable

Answer 7

utilizo algo como esto. No es muy sofisticado pero debería funcionar.

    queue<int> tem; 

    while(!q1.empty()) // q1 is your initial queue. 
    {
        int u = q1.front(); 

        // do what you need to do with this value.  

        q1.pop(); 
        tem.push(u); 
    }


    while(!tem.empty())
    {
        int u = tem.front(); 
        tem.pop(); 
        q1.push(u); // putting it back in our original queue. 
    }

Se trabajará porque cuando usted hace estallar algo de Q1, y empujarlo hacia TEM, se convierte en el primer elemento de TEM. Así, en el tem final se convierte en una réplica de la Q1.

Answer 8

En pocas palabras:. No

Hay un corte, el uso de vectores como contenedor underlaid, por lo queue::front volverá referencia válida, convertirlo a puntero un iterate hasta <= queue::back

Answer 9

std::queue es un adaptador del recipiente, y puede especificar el recipiente utilizado (por defecto se utilizan una deque). Si necesita una funcionalidad más allá de que en el adaptador sólo tiene que utilizar un deque u otro contenedor directamente.