Por que std :: queue :: pop retorna valor.?

Passei por esta página, mas não sou capaz de entender o motivo. Lá é mencionado que

"é mais sensato não retornar nenhum valor e exigir que os clientes usem front () para inspecionar o valor na frente da fila"

Mas a inspeção de um elemento de front () também exigia que esse elemento fosse copiado em lvalue. Por exemplo, neste segmento de código

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

/ * aqui temporário será criado no RHS que será atribuído ao resultado e, se retornos por referência, o resultado será invalidado após a operação pop * /

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

na quinta linha, o objeto cout cria primeiro uma cópia do myqueue.front () e depois atribui isso ao resultado. Então, qual é a diferença, a função pop poderia ter feito a mesma coisa.

Então, qual é a diferença, a função pop poderia ter feito a mesma coisa.

Poderia realmente ter feito a mesma coisa. O motivo disso não ocorreu é porque um pop que retornou o elemento popped não é seguro na presença de exceções (tendo que retornar por valor e, assim, criar uma cópia).

Considere este cenário (com uma implementação pop ingênua / inventada, para ilustrar meu argumento):

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
    }

Se o construtor de cópias de T lançar no retorno, você já alterou o estado da fila ( top_positionna minha implementação ingênua) e o elemento será removido da fila (e não retornado). Para todas as intenções e propósitos (não importa como você captura a exceção no código do cliente), o elemento na parte superior da fila é perdido.

Essa implementação também é ineficiente no caso em que você não precisa do valor pop-up (isto é, cria uma cópia do elemento que ninguém usará).

Isso pode ser implementado com segurança e eficiência, com duas operações separadas ( void pope const T& front()).

A página à qual você vinculou responde à sua pergunta.

Para citar toda a seção relevante:

Alguém pode se perguntar por que pop () retorna nulo, em vez de value_type. Ou seja, por que alguém deve usar front () e pop () para examinar e remover o elemento na frente da fila, em vez de combinar os dois em uma única função de membro? De fato, há uma boa razão para esse design. Se pop () retornasse o elemento front, ele teria que retornar por valor e não por referência: o retorno por referência criaria um ponteiro pendente. O retorno por valor, no entanto, é ineficiente: envolve pelo menos uma chamada de construtor de cópia redundante. Como é impossível para pop () retornar um valor de maneira a ser eficiente e correta, é mais sensato não retornar nenhum valor e exigir que os clientes usem front () para inspecionar o valor em a frente da fila.

O C ++ é projetado com eficiência em mente, sobre o número de linhas de código que o programador precisa escrever.

pop não pode retornar uma referência ao valor removido, pois está sendo removido da estrutura de dados; portanto, a que referência deve se referir? Pode retornar por valor, mas e se o resultado de pop não for armazenado em nenhum lugar? Então se perde tempo copiando o valor desnecessariamente.

Com a implementação atual, isso é válido:

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

Se pop retornasse uma referência, assim:

value_type& pop();

Em seguida, o código a seguir pode falhar, pois a referência não é mais válida:

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

Por outro lado, se ele retornasse um valor diretamente:

value_type pop();

Então você precisaria fazer uma cópia para esse código funcionar, o que é menos eficiente:

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

A partir do C ++ 11, seria possível arquivar o comportamento desejado usando a semântica de movimentação. Like pop_and_move. Portanto, o construtor de cópias não será chamado e o desempenho dependerá apenas do construtor de movimentação.

Você pode fazer isso totalmente:

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

Ou, se você quiser o valor em uma variável, use uma referência:

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

Além disso: o termo 'mais sensível' é uma forma subjetiva de 'examinamos os padrões de uso e descobrimos mais necessidade de uma divisão'. (Tenha certeza: a linguagem C ++ não está evoluindo levemente ...)

Eu acho que a melhor solução seria adicionar algo como

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

onde value receberá o valor popped.

A vantagem é que ele pode ser implementado usando um operador de atribuição de movimento, enquanto usar front + pop fará uma cópia.