blocks|key|4661054|text|这是因为bar返回的值是一个临时值。因为它的存在是暂时的，所以不能使用指针或引用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4661055|但是，如果存储该临时对象的副本(如在第二次更改中)，则不再将对临时对象的引用传递给foo，而是传递对实际有形对象的引用。在第一种情况下，当您更改为对常量对象的引用时，编译器确保临时对象保持足够长的时间(按照C%2B%2B规范)。|4661056|entityMap^0|4|3|0|15|3|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

It's because the value returned by <code>bar</code> is a temporary value. As it's existence is temporary, you can't use a pointer or reference to that.

However, if you store a copy of that temporary, as in your second change, you no longer pass a reference to a temporary object to <code>foo</code>, but a reference to a real tangible object. And in the first case, when you change to a reference to a constant object, the compiler makes sure the temporary object stays around long enough (as per the C++ specification).

blocks|key|45648|text|可修改(lvalue-)引用不绑定到临时值。但是，const-引用确实绑定到临时值。它与值返回的对象是否为const无关；这只是一个表达式是否是临时表达式的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|45649|例如，以下内容是有效的：|45650|struct+C+{+void+i_am_non_const()+{}+};

int+main()
{
++++bar().i_am_non_const();
}|code-block|syntax|javascript|45651|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Modifiable (lvalue-)references do not bind to temporary values. However, const-references do bind to temporary values. It has nothing to do with whether the object returned by value is const or not; it's simply a matter of whether the expression is temporary or not.

For example, the following is valid:

<pre><code>struct C { void i_am_non_const() {} };

int main()
{
 bar().i_am_non_const();
}
</code></pre>

blocks|key|45661|text|问题不在于bar的声明，而在于foo的声明。foo接受一个非const引用，临时人员只能绑定到const引用(然后延长临时引用的生存期，使其与绑定到的引用相匹配)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|45662|允许非const引用绑定到临时引用没有多大意义。非const引用意味着它将修改任何绑定到它的对象。修改一个临时的没有任何用途，因为它的生命周期是有限的，一旦它超出范围，更改就会丢失。|45663|entityMap^0|5|3|F|3|M|3|U|5|1B|5|0|3|5|P|5|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|I|$]]

The issue is not with the declaration of <code>bar</code> but with that of <code>foo</code>. <code>foo</code> takes a non-<code>const</code> reference, and temporaries can only bind to <code>const</code> references (which then extends the lifetime of the temporary to match that of the reference it is bound to).

Allowing a non-<code>const</code> reference to bind to a temporary doesn't make much sense. A non-<code>const</code> reference implies that it will modify whatever object is bound to it. Modifying a temporary serves no purpose since its lifetime is limited and the changes will be lost as soon as it goes out of scope.

blocks|key|45688|text|这里适用的规则是，您不能创建对临时对象的非const引用。如果foo被声明为foo(const+C&)，那么代码就可以了。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|45689|不过，临时对象本身并不是const；您可以在其上调用非const成员函数，例如bar().non_const_member_function()。|45690|使用C%2B%2B11，可以编写foo以获取rvalue引用；在这种情况下，调用是可以的：|45691|void+foo(C&&);
foo(bar());++//+okay|code-block|syntax|javascript|45692|entityMap^0|V|3|12|D|0|13|X|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|Z|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

The applicable rule here is that you can't create a non-const reference to a temporary object. If <code>foo</code> was declared as <code>foo(const C&amp;)</code> the code would be okay.

The temporary object itself is not const, though; you can call non-const member functions on it, e.g., <code>bar().non_const_member_function()</code>.

With C++11, foo can be written to take an rvalue reference; in that case, the call would be okay:

<pre><code>void foo(C&amp;&amp;);
foo(bar()); // okay
</code></pre>

blocks|key|45720|text|这是一个设计上的选择。这里没有什么本质上是不可能的。只是设计上的选择。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|45721|在C%2B%2B11中，您有第三种选择，这也是更好的选择：|45722|void+foo(C+&&+c)+{}+|code-block|syntax|javascript|45723|也就是说，使用rvalue-引用。|45724|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

It is a design choice. There is nothing inherently impossible here. Just a design choice.

In C++11, you have a third alternative which is also superior alternative:

<pre><code>void foo(C &amp;&amp; c) {} 
</code></pre>

That is, use rvalue-references.

blocks|key|4661210|text|真正的，残酷的事实是，得到一个临时值的引用是没有意义的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4661211|通过引用传递对象的要点是，它允许您修改它的状态。但是，在临时的情况下，就其本质而言，能够修改它并不特别有帮助，因为您无法在稍后的代码中获得对它的另一个引用来查看更改。|4661212|但是，在有const引用的情况下，这有点不同。由于您将只从const引用中阅读，因此能够在那里使用临时引用是完全有意义的。这就是为什么编译器将为您“攻击”它，并给临时用户一个更永久的地址，您希望将这些地址“转换”为const引用。|offset|length|style|CODE|4661213|因此，规则是不能获得对临时值的非const引用。(这一点在C%2B%2B11中略有改变，在这里我们有一种新类型的引用，用于这个精确的目的，但是方法需要以一种特殊的方式来处理那些引用。)|4661214|entityMap^0|0|0|5|5|T|5|2Z|5|0|G|5|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]|$F|S|G|T|H|I]|$F|U|G|V|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@$F|X|G|Y|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|M|$]]

The real, hard truth is that it makes no sense to get a reference to a temporary value.

The big point of passing an object by reference is that it allows you to modify its state. However, in the case of a temporary, by its very nature, it would not be particularly helpful to be able to modify it, since you have no way of getting another reference to it later in your code to see the changes.

However, this is somewhat different in the case you have a <code>const</code> reference. Since you'll only ever read from a <code>const</code> reference, it makes total sense to be able to use temporaries there. This is why the compiler will "hack" around it for you, and give a more permanent address to temporaries that you want to "turn" into <code>const</code> references.

So, the rule is that you cannot get a non-<code>const</code> reference to a temporary value. (This slightly changed with C++11, where we have a new type of references that serve this exact purpose, but methods are expected to deal with those in a special way.)

blocks|key|45756|text|这不是康斯特，但这是一个暂时的价值。因此，它不能绑定到非const+lvalue引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|45757|它可以绑定到const或rvalue引用，您可以在其上调用成员函数(const或not)：|45758|class+C+{+void+f();+};

void+foo_const(C+const+&);
void+foo_rvalue(C+&&);

foo_const(+bar()+);++//+OK
foo_rvalue(+bar()+);+//+OK
bar().f();+++++++++++//+OK|code-block|syntax|javascript|45759|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

It's not const, but it is a temporary rvalue. As such, it can't bind to a non-const lvalue reference.

It can bind to a const or rvalue reference, and you can call member functions (const or not) on it:

<pre><code>class C { void f(); };

void foo_const(C const &amp;);
void foo_rvalue(C &amp;&amp;);

foo_const( bar() ); // OK
foo_rvalue( bar() ); // OK
bar().f(); // OK
</code></pre>

blocks|key|4661260|text|谢谢大家的回答:-)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4661261|我在这里收集你的好主意-)|4661262|回答|4661263|按值返回的是而不是+const。例如，我们可以按值调用非const成员函数的返回。|offset|length|style|BOLD|CODE|4661264|class+C+{+
++public:
++++int+x;
++++void+set+(int+n)+{+x+=+n;+}++//+non-const+function
};

C+bar()++{+return+C();+}

int+main+()
{
++++bar.set(5);+//+OK
}|code-block|syntax|javascript|4661265|但是C%2B%2B不允许对临时对象的非const引用。|4661266|但是，C%2B%2B11允许对临时对象的非const引用。;-)|4661267|解释|4661268|class+C+{};

void+foo+(C&+c)+{}

C+bar()++{+return+C();+}
//bar()+returns+a+temporary+object
//temporary+objects+cannot+be+non-const+referenced

int+main()
{
++//foo()+wants+a+mutable+reference+(i.e.+non-const)
++foo(+bar()+);+//+=>+compilation+error+++++
}+++++++++++++++++|4661269|三次修复|4661270|更改foo声明
无效foo+(const+C&+c)+{}|ordered-list-item|4661271|使用另一个对象
int+main()+{+c；foo(+c=+bar()+)；}|4661272|使用C%2B%2B11+rvalue-引用
无效foo(C+&C&+c)+{}|4661273|4661274|4661275|此外，|4661276|要确认临时对象是const，上述源代码失败的原因是相同的：|4661277|class+C+{};

void+foo(C&+c)+{}

int+main()++++++++++++++++
{
++foo(+C()+);
}++++++++++++|4661278|entityMap^0|0|0|0|6|3|A|5|0|0|2|B|0|0|0|0|0|2|3|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1J|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1K|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1L|8|@$H|1M|I|1N|J|K]|$H|1O|I|1P|J|L]]|9|@]|A|$]]|$1|M|3|N|5|O|7|1Q|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|6|7|1R|8|@$H|1S|I|1T|J|K]]|9|@]|A|$]]|$1|T|3|U|5|6|7|1U|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1V|8|@]|9|@]|A|$]]|$1|X|3|Y|5|O|7|1W|8|@]|9|@]|A|$P|Q]]|$1|Z|3|10|5|6|7|1X|8|@]|9|@]|A|$]]|$1|11|3|12|5|13|7|1Y|8|@$H|1Z|I|20|J|L]]|9|@]|A|$]]|$1|14|3|15|5|13|7|21|8|@]|9|@]|A|$]]|$1|16|3|17|5|13|7|22|8|@]|9|@]|A|$]]|$1|18|3|-4|5|6|7|23|8|@]|9|@]|A|$]]|$1|19|3|-4|5|6|7|24|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|25|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|26|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|O|7|27|8|@]|9|@]|A|$P|Q]]|$1|1G|3|-4|5|6|7|28|8|@]|9|@]|A|$]]]|1H|$]]

Thank you all for your answers :-) 
Here I gather your good ideas ;-)

<h2>Answer</h2>

Return by value is not <code>const</code>. For example, we can call non-const member functions of return by value:

<pre><code>class C { 
 public:
 int x;
 void set (int n) { x = n; } // non-const function
};

C bar() { return C(); }

int main ()
{
 bar.set(5); // OK
}
</code></pre>

But C++ does not allow non-const references to temporary objects. 
However C++11 allow non-const rvalue-references to temporary objects. ;-)

<h2>Explanation</h2>

<pre><code>class C {};

void foo (C&amp; c) {}

C bar() { return C(); }
//bar() returns a temporary object
//temporary objects cannot be non-const referenced

int main()
{
 //foo() wants a mutable reference (i.e. non-const)
 foo( bar() ); // =&gt; compilation error 
} 
</code></pre>

<h2>Three fixes</h2>

<ol>
<li>Change <code>foo</code> declaration

<pre><code> void foo (const C&amp; c) {}
</code></pre></li>
<li>Use another object

<pre><code> int main() 
 {
 C c;
 foo( c = bar() );
 }
</code></pre></li>
<li>Use C++11 rvalue-reference

<pre><code> void foo(C &amp;&amp; c) {}
</code></pre></li>
</ol>

<h2>Moreover</h2>

To confirm temporary objects are const, this above source code fails for the same reason:

<pre><code>class C {};

void foo(C&amp; c) {}

int main() 
{
 foo( C() );
} 
</code></pre>

This code does not compile:

<pre><code>class C {};

void foo (C&amp; c) {}

C bar() { return C(); }

int main() 
{
 foo(bar());
} 
</code></pre>

Compilation error (GCC 4.1.2) in line <code>foo(bar())</code>: 

<blockquote>
 invalid initialization of non-const reference of type 'C&amp;' 
 from a temporary of type 'C'
</blockquote>

As <code>bar()</code> returns a <code>mutable</code> object, it should compile... 
Why C++ does not allow this above code?

 
EDIT: I have summarize in <a href="https://stackoverflow.com/a/13385827/938111">an answer below</a> all good ideas from all answers ;-)

Is return by value always const?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

此代码不编译：class C {};void foo (C& c) {}C bar() { return C(); }int main()              {  foo(bar());}               foo(bar())行中的编译错误(GCC 4.1.2)从临时类型“C”中初始化“C&”类型的...

问按价值返回总是有价值的吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问按价值返回总是有价值的吗？EN