¿Por qué std :: queue :: pop no devuelve el valor?

Revisé esta página pero no puedo obtener el motivo de la misma. Allí se menciona que

"Es más sensato que no devuelva ningún valor y que requiera que los clientes usen front () para inspeccionar el valor al principio de la cola"

Pero inspeccionar un elemento desde front () también requería que ese elemento se copiara en lvalue. Por ejemplo, en este segmento de código

std::queue<int> myqueue;
int myint;
int result;
std::cin >> myint;
myqueue.push (myint);

/ * aquí se creará temporal en RHS que se asignará al resultado, y en caso de que se devuelva por referencia, el resultado se invalidará después de la operación pop * /

result = myqueue.front();  //result.
std::cout << ' ' << result;
myqueue.pop();

en la quinta línea, el objeto cout primero crea una copia de myqueue.front () y luego lo asigna al resultado. Entonces, cuál es la diferencia, la función pop podría haber hecho lo mismo.

Entonces, cuál es la diferencia, la función pop podría haber hecho lo mismo.

De hecho, podría haber hecho lo mismo. La razón por la que no lo hizo es porque una ventana emergente que devolvió el elemento emergente no es segura en presencia de excepciones (tener que regresar por valor y, por lo tanto, crear una copia).

Considere este escenario (con una implementación pop ingenua / inventada, para ilustrar mi punto):

template<class T>
class queue {
    T* elements;
    std::size_t top_position;
    // stuff here
    T pop()
    {
        auto x = elements[top_position];
        // TODO: call destructor for elements[top_position] here
        --top_position;  // alter queue state here
        return x;        // calls T(const T&) which may throw
    }

Si el constructor de copia de T arroja un retorno, ya ha alterado el estado de la cola ( top_positionen mi implementación ingenua) y el elemento se elimina de la cola (y no se devuelve). Para todos los efectos (sin importar cómo detecte la excepción en el código del cliente), el elemento en la parte superior de la cola se pierde.

Esta implementación también es ineficaz en el caso de que no necesite el valor emergente (es decir, crea una copia del elemento que nadie usará).

Esto se puede implementar de manera segura y eficiente, con dos operaciones separadas ( void popy const T& front()).

La página a la que ha vinculado responde a su pregunta.

Para citar toda la sección relevante:

Uno podría preguntarse por qué pop () devuelve void, en lugar de value_type. Es decir, ¿por qué se debe usar front () y pop () para examinar y eliminar el elemento al principio de la cola, en lugar de combinar los dos en una función de un solo miembro? De hecho, hay una buena razón para este diseño. Si pop () devolvió el elemento frontal, tendría que regresar por valor en lugar de por referencia: regresar por referencia crearía un puntero colgante. Sin embargo, el retorno por valor es ineficaz: implica al menos una llamada al constructor de copia redundante. Dado que es imposible que pop () devuelva un valor de tal manera que sea eficiente y correcto, es más sensato que no devuelva ningún valor y que requiera que los clientes usen front () para inspeccionar el valor en al frente de la cola.

C ++ está diseñado teniendo en cuenta la eficiencia, sobre la cantidad de líneas de código que el programador tiene que escribir.

pop no puede devolver una referencia al valor que se elimina, ya que se elimina de la estructura de datos, entonces, ¿a qué debería referirse la referencia? Podría devolver por valor, pero ¿qué pasa si el resultado de pop no se almacena en ningún lugar? Entonces se pierde tiempo copiando el valor innecesariamente.

Con la implementación actual, esto es válido:

int &result = myqueue.front();
std::cout << result;
myqueue.pop();

Si pop devuelve una referencia, como esta:

value_type& pop();

Entonces el siguiente código podría fallar, ya que la referencia ya no es válida:

int &result = myqueue.pop();
std::cout << result;

Por otro lado, si devuelve un valor directamente:

value_type pop();

Entonces necesitaría hacer una copia para que este código funcione, lo cual es menos eficiente:

int result = myqueue.pop();
std::cout << result;

A partir de C ++ 11 sería posible archivar el comportamiento deseado utilizando la semántica de movimiento. Al igual pop_and_move. Por lo tanto, no se llamará al constructor de copia y el rendimiento dependerá únicamente del constructor de movimiento.

Puedes hacer esto totalmente:

std::cout << ' ' << myqueue.front();

O, si desea el valor en una variable, use una referencia:

const auto &result = myqueue.front();
if (result > whatever) do_whatever();
std::cout << ' ' << result;

Además de eso: la redacción 'más sensible' es una forma subjetiva de 'buscamos en los patrones de uso y encontramos más necesidad de una división'. (Tenga la seguridad: el lenguaje C ++ no está evolucionando a la ligera ...)

Creo que la mejor solución sería agregar algo como

std::queue::pop_and_store(value_type& value);

donde value recibirá el valor reventado.

La ventaja es que podría implementarse usando un operador de asignación de movimiento, mientras que usar front + pop hará una copia.