Почему std :: queue :: pop не возвращает значение?

Я просмотрел эту страницу, но не могу понять причину того же. Там упоминается, что

"для него более разумно вообще не возвращать никакого значения и требовать от клиентов использования front () для проверки значения в начале очереди"

Но проверка элемента из front () также требует, чтобы этот элемент был скопирован в lvalue. Например, в этом сегменте кода

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

/ * здесь временно будет создано на RHS, которое будет назначено результату, и в случае возврата по ссылке результат будет недействительным после операции pop * /

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

в пятой строке объект cout сначала создает копию myqueue.front (), а затем присваивает ее результату. Итак, в чем разница, функция pop могла бы сделать то же самое.

Итак, в чем разница, функция pop могла бы сделать то же самое.

Он действительно мог сделать то же самое. Причина, по которой этого не произошло, заключается в том, что всплывающий элемент, который вернул всплывающий элемент, небезопасен при наличии исключений (необходимо возвращать по значению и, таким образом, создавать копию).

Рассмотрим этот сценарий (с наивной / выдуманной реализацией pop, чтобы проиллюстрировать мою точку зрения):

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
    }

Если конструктор копирования T выдает при возврате, вы уже изменили состояние очереди ( top_positionв моей наивной реализации), и элемент удаляется из очереди (и не возвращается). Для всех намерений и целей (независимо от того, как вы поймаете исключение в клиентском коде) элемент в верхней части очереди теряется.

Эта реализация также неэффективна в том случае, когда вам не нужно извлекаемое значение (т.е. создается копия элемента, которую никто не будет использовать).

Это можно реализовать безопасно и эффективно с помощью двух отдельных операций ( void popи const T& front()).

Страница, на которую вы ссылаетесь, отвечает на ваш вопрос.

Чтобы процитировать весь соответствующий раздел:

Можно задаться вопросом, почему pop () возвращает void вместо value_type. То есть, почему нужно использовать front () и pop () для проверки и удаления элемента в начале очереди, вместо того, чтобы объединять их в одной функции-члене? На самом деле, для такого дизайна есть веская причина. Если pop () вернет передний элемент, он должен будет вернуться по значению, а не по ссылке: возврат по ссылке создаст висящий указатель. Однако возврат по значению неэффективен: он включает в себя как минимум один вызов конструктора избыточной копии. Поскольку pop () не может возвращать значение таким образом, чтобы быть одновременно эффективным и правильным, для него более разумно вообще не возвращать никакого значения и требовать от клиентов использования front () для проверки значения в начало очереди.

C ++ разработан с учетом эффективности, с учетом количества строк кода, которые программист должен написать.

pop не может вернуть ссылку на значение, которое было удалено, поскольку оно удаляется из структуры данных, поэтому на что должна ссылаться ссылка? Он может возвращаться по значению, но что, если результат pop нигде не сохраняется? Тогда время тратится на ненужное копирование значения.

В текущей реализации это действительно так:

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

Если pop вернет ссылку, например:

value_type& pop();

Тогда может произойти сбой следующего кода, поскольку ссылка больше не действительна:

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

С другой стороны, если он вернет значение напрямую:

value_type pop();

Затем вам нужно будет сделать копию, чтобы этот код заработал, что менее эффективно:

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

Начиная с C ++ 11, можно было бы архивировать желаемое поведение, используя семантику перемещения. Нравится pop_and_move. Таким образом, конструктор копирования не будет вызываться, а производительность будет зависеть только от конструктора перемещения.

Вы можете сделать это полностью:

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

Или, если вам нужно значение переменной, используйте ссылку:

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

Рядом с этим: формулировка «более разумный» - это субъективная форма «мы изучили шаблоны использования и обнаружили большую потребность в разделении». (Будьте уверены: язык C ++ развивается нелегко ...)

Думаю, лучшим решением было бы добавить что-нибудь вроде

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

где value получит всплывающее значение.

Преимущество заключается в том, что это можно реализовать с помощью оператора присваивания перемещения, а использование front + pop сделает копию.