blocks|key|153419|text|你完全可以做到：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|153420|std::cout+<<+'+'+<<+myqueue.front();|code-block|syntax|javascript|153421|或者，如果需要变量中的值，请使用引用：|153422|const+auto+&result+=+myqueue.front();
if+(result+>+whatever)+do_whatever();
std::cout+<<+'+'+<<+result;|153423|紧接着：“更明智”这句话是“我们研究了使用模式，发现更需要拆分”的主观形式。(请放心:+C%2B%2B语言不会轻易演变...)|153424|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can totally do this:

<pre><code>std::cout &lt;&lt; ' ' &lt;&lt; myqueue.front();
</code></pre>

Or, if you want the value in a variable, use a reference:

<pre><code>const auto &amp;result = myqueue.front();
if (result &gt; whatever) do_whatever();
std::cout &lt;&lt; ' ' &lt;&lt; result;
</code></pre>

Next to that: the wording 'more sensible' is a subjective form of 'we looked into usage patterns and found more need for a split'. (Rest assured: the C++ language is not evolving lightly...)

blocks|key|150646|text|pop不能返回对被移除的值的引用，因为它正被从数据结构中移除，那么引用应该引用什么呢？它可以通过值返回，但是如果pop的结果没有存储在任何地方呢？那么时间就浪费在了不必要的复制值上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|150647|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

pop cannot return a reference to the value that is removed, as it is being removed from the data structure, so what should the reference refer to? It could return by value, but what if the result of pop is not stored anywhere? Then time is wasted copying the value unnecessarily.

blocks|key|153457|text|对于当前的实现，这是有效的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|153458|int+&result+=+myqueue.front();
std::cout+<<+result;
myqueue.pop();|code-block|syntax|javascript|153459|如果pop返回一个引用，如下所示：|153460|value_type&+pop();|153461|那么下面的代码可能会崩溃，因为引用不再有效：|153462|int+&result+=+myqueue.pop();
std::cout+<<+result;|153463|另一方面，如果它会直接返回一个值：|153464|value_type+pop();|153465|然后，您需要复制此代码才能工作，这效率较低：|153466|int+result+=+myqueue.pop();
std::cout+<<+result;|153467|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

With the current implementation, this is valid:

<pre><code>int &amp;result = myqueue.front();
std::cout &lt;&lt; result;
myqueue.pop();
</code></pre>

If pop would return a reference, like this:

<pre><code>value_type&amp; pop();
</code></pre>

Then the following code could crash, since the reference is not valid anymore:

<pre><code>int &amp;result = myqueue.pop();
std::cout &lt;&lt; result;
</code></pre>

On the other hand, if it would return a value directly:

<pre><code>value_type pop();
</code></pre>

Then you would need to do a copy for this code to work, which is less efficient:

<pre><code>int result = myqueue.pop();
std::cout &lt;&lt; result;
</code></pre>

blocks|key|2946460|text|您所链接的页面回答了您的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2946461|引用相关的整个章节：|2946462|人们可能会奇怪为什么|2946463|+()返回value_type，而不是void。也就是说，为什么必须使用front()和pop()来检查和删除队列前面的元素，而不是将这两个元素组合在一个成员函数中？事实上，这种设计有一个很好的理由。如果pop()返回了front元素，那么它必须通过值返回，而不是通过引用返回:通过引用返回将创建一个悬空指针。然而，按值返回的效率很低:它至少涉及一个冗余的复制构造函数调用。由于pop()不可能以既高效又正确的方式返回值，因此更明智的做法是不返回值，并要求客户端使用front()检查队列前面的值。|blockquote|2946464|2946465|2946466|C%2B%2B在设计时考虑到了效率，超过了程序员必须编写的代码行数。|2946467|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|S|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

The page you have linked to answers your question.

To quote the whole section relevant:

<blockquote>
 One might wonder why pop() returns void, instead of value_type. That is, why must one use front() and pop() to examine and remove the element at the front of the queue, instead of combining the two in a single member function? In fact, there is a good reason for this design. If pop() returned the front element, it would have to return by value rather than by reference: return by reference would create a dangling pointer. Return by value, however, is inefficient: it involves at least one redundant copy constructor call. Since it is impossible for pop() to return a value in such a way as to be both efficient and correct, it is more sensible for it to return no value at all and to require clients to use front() to inspect the value at the front of the queue. 
</blockquote>

C++ is designed with efficiency in mind, over the number of lines of code the programmer has to write.

blocks|key|150710|text|所以，有什么不同，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|150711|函数也可以做同样的事情。|blockquote|150712|150713|150714|它确实可以做同样的事情。它没有这样做的原因是，返回弹出元素的pop在存在异常的情况下是不安全的(必须通过值返回，从而创建一个副本)。|150715|考虑这个场景(使用一个简单的/虚构的pop实现，来说明我的观点)：|150716|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
++++}|code-block|syntax|javascript|150717|如果T的复制构造函数在返回时抛出，则您已经更改了队列的状态(在我的原始实现中为top_position)，并且该元素将从队列中删除(并且不返回)。无论出于何种目的(无论您如何捕获客户端代码中的异常)，队列顶部的元素都会丢失。|offset|length|style|CODE|150718|当您不需要弹出的值时，这种实现也是低效的(即，它创建了一个没有人会使用的元素的副本)。|150719|这可以通过两个独立的操作(void+pop和const+T&+front())安全有效地实现。|150720|entityMap^0|0|0|0|0|0|0|0|13|C|0|0|D|8|M|G|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|15|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|16|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|17|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|18|8|@$R|19|S|1A|T|U]]|9|@]|A|$]]|$1|V|3|W|5|6|7|1B|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1C|8|@$R|1D|S|1E|T|U]|$R|1F|S|1G|T|U]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|10|$]]

<blockquote>
 So, whats the difference, pop function could have done the same thing.
</blockquote>

It could indeed have done the same thing. The reason it didn't, is because a pop that returned the popped element is unsafe in the presence of exceptions (having to return by value and thus creating a copy).

Consider this scenario (with a naive/made up pop implementation, to ilustrate my point):

<pre><code>template&lt;class T&gt;
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&amp;) which may throw
 }
</code></pre>

If the copy constructor of T throws on return, you have already altered the state of the queue (<code>top_position</code> in my naive implementation) and the element is removed from the queue (and not returned). For all intents and purposes (no matter how you catch the exception in client code) the element at the top of the queue is lost.

This implementation is also inefficient in the case when you do not need the popped value (i.e. it creates a copy of the element that nobody will use).

This can be implemented safely and efficiently, with two separate operations (<code>void pop</code> and <code>const T&amp; front()</code>).

blocks|key|2733876|text|我认为最好的解决方案是添加如下内容|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2733877|std::queue::pop_and_store(value_type&+value);|code-block|syntax|javascript|2733878|其中value将接收弹出的值。|2733879|优点是它可以使用移动赋值操作符实现，而使用front+%2B+pop将进行复制。|2733880|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I think the best solution would be to add something like 

<pre><code>std::queue::pop_and_store(value_type&amp; value);
</code></pre>

where value will receive the popped value.

The advantage is that it could be implemented using a move assignment operator, while using front + pop will make a copy.

blocks|key|2733894|text|从C%2B%2B11开始，可以使用移动语义来归档所需的行为。比如pop_and_move。因此复制构造函数将不会被调用，性能将仅取决于移动构造函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2733895|entityMap^0|S|C|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Starting from C++11 it would possible to archive desired behavior using move semantics. Like <code>pop_and_move</code>. So copy constructor will not be called, and performance will depend on move constructor only.

I went through this <a href="http://www.sgi.com/tech/stl/queue.html#3" rel="noreferrer">page</a> but I am not able to get the reason for the same . There it is mentioned that 

<blockquote>
 "it is more sensible for it to return no value at all and to require
 clients to use front() to inspect the value at the front of the queue"
</blockquote>

But inspecting an element from front() also required that element to be copied in lvalue. For example in this code segment

<pre><code>std::queue&lt;int&gt; myqueue;
int myint;
int result;
std::cin &gt;&gt; myint;
myqueue.push (myint);
</code></pre>

/* here temporary will be created on RHS which will be assigned to result, and in case
 if returns by reference then result will be rendered invalid after pop operation */

<pre><code>result = myqueue.front(); //result.
std::cout &lt;&lt; ' ' &lt;&lt; result;
myqueue.pop();
</code></pre>

on fifth line cout object first creates a copy of myqueue.front() then assigns that to result. So, whats the difference, pop function could have done the same thing.

Why doesn't std::queue::pop return value.?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我通过这个，但我不能得到同样的原因。这里提到的是“更明智的做法是完全不返回值，并要求客户端使用front()检查队列前面的值。”但是从front()检查一个元素也需要将该元素复制到lvalue中。例如，在下面的代码段中std::queue<int> myqueue;int myint;int result;std::c...

问为什么std::queue::pop返回值。？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么std::queue::pop返回值。？EN