blocks|key|2037729|text|是的，那样的话会复印一份。如果您像这样更改函数声明：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2037730|subline_t+&subline(int+x1,+int+x2,+int+id)+{|code-block|syntax|javascript|2037731|则不会创建任何副本。但是，在您的特定情况下，返回对堆栈上分配的对象的引用是无效的。问题是，在调用者有机会使用对象之前，对象就会被析构和失效。|2037732|这与C%2B%2B的通用Return+Value+Optimization相关，在您所描述的情况下，它可以避免执行实际的复制操作。最终结果(或应该是)与复制完成的结果相同，但您应该意识到优化。在某些情况下，这种优化的存在可能会改变程序的可观察行为。|offset|length|2037733|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Return_value_optimization^0|0|0|0|8|P|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Yes, in that case there will be a copy made. If you change the function declaration like this:

<pre><code>subline_t &amp;subline(int x1, int x2, int id) {
</code></pre>

then no copy will be made. However, in your specific case it would not be valid to return a reference to an object allocated on the stack. The problem is that the object would be destructed and invalidated before the caller had a chance to use it.

This is related to the common <a href="http://en.wikipedia.org/wiki/Return_value_optimization" rel="noreferrer">Return Value Optimization</a> for C++ that can avoid doing an actual copy operation in the case you have described. The end result is (or should be) the same as if a copy were done, but you should be aware of the optimization. The presence of this optimization can, in some cases, change the observable behaviour of the program.

blocks|key|1824053|text|在本例中，它将返回一个副本|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1824054|如果你的代码是|1824055|subline_t&+subline(int,+int)|code-block|syntax|javascript|1824056|然后，它将返回一个引用，这将产生未定义的行为。|1824057|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|$]]

In your case , it will return a copy

If your code was

<pre><code>subline_t&amp; subline(int, int)
</code></pre>

then it would return a reference, which would yield in undefined behaviour.

blocks|key|1824367|text|是的，对于声明返回struct的函数，这样的结构的return将复制它(尽管编译器有权优化复制，但基本上在它可以证明优化在语义上是无害的情况下，您可以推断“好像”复制是有保证的)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1824368|但是，既然您已经将其标记为C%2B%2B，而不是C，为什么不为您的struct提供一个构造函数，而不是...？看起来更清晰、更直接...！-)|1824369|entityMap^0|9|6|P|6|0|T|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

Yes, for a function declared to return a <code>struct</code>, <code>return</code> of such a struct will copy it (though the compiler is empowered to optimize the copy away, essentially in cases where it can prove the optimization is semantically innocuous, you can reason "as if" the copying was guaranteed).

However, since you did tag this as C++, not C, why not supply your <code>struct</code> with a constructor, instead...? Seems clearer and more direct...!-)

blocks|key|2038062|text|是的，退货是复印件|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2038063|subline_t+subline(int+x1,+int+x2,+int+id)+{
++++++++subline_t+t+=+{+x1,+x2,+id+};
++++++++return+t;
}|code-block|syntax|javascript|2038064|如果你放置了一个引用，那么它就不是一个副本|2038065|subline_t+&+subline(int+x1,+int+x2,+int+id)+{
++++++++subline_t+t+=+{+x1,+x2,+id+};
++++++++return+t;+//+will+result+in+corruption+because+returning+a+reference
}|2038066|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|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

yes , the return is a copy

<pre><code>subline_t subline(int x1, int x2, int id) {
 subline_t t = { x1, x2, id };
 return t;
}
</code></pre>

If you put a referencer, then its not a copy

<pre><code>subline_t &amp; subline(int x1, int x2, int id) {
 subline_t t = { x1, x2, id };
 return t; // will result in corruption because returning a reference
}
</code></pre>

blocks|key|2038102|text|它总是会返回一个副本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2038103|如果要避免在返回时复制对象的性能影响，可以声明一个指针，使用new生成该对象的一个实例，然后返回该指针。在这种情况下，指针将被复制，但对象不会被复制。|2038104|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

It will always return a copy.

If you want to avoid the performance hit of copying the object on return, you can declare a pointer, build an instance of the object using new, and return the pointer. In that case, the pointer will be copied, but the object won't be.

blocks|key|1824466|text|它返回一个副本，这是您希望它做的事情。将其更改为返回引用将导致赋值到行中出现未定义的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1824467|然而，在C%2B%2B中，惯用的方法是使用构造函数和赋值列表。这更好地封装了代码和数据结构，并允许您避免编译器可以自由构造/析构/复制的过多中间对象。|1824468|struct+subline_t+{
++++++++int+x1;/*top*/
++++++++int+x2;/*bottom*/
++++++++int+id;

//+constructor+which+initialises+values+with+assignment+list.
++subline_t(int+the_x1,+int+the_x2,+int+the_id)+:
++++x1(the_x1),
++++x2(the_x2),
++++id(the_id)
++{
++}
};


int+main(){
++++subline_t+line2(0,0,0);+//+never+requires+a+copy+or+assignment.
}|code-block|syntax|javascript|1824469|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 returns a copy, which is what you want it to do. Changing it to return a reference will result in undefined behaviour in the assignment to line.

However, the idiomatic way to do this in C++ is with constructors and assignment lists. This encapsulates code and data structures better, and allows you to avoid the plethora of intermediate objects that compilers are free to construct/destruct/copy.

<pre><code>struct subline_t {
 int x1;/*top*/
 int x2;/*bottom*/
 int id;

// constructor which initialises values with assignment list.
 subline_t(int the_x1, int the_x2, int the_id) :
 x1(the_x1),
 x2(the_x2),
 id(the_id)
 {
 }
};


int main(){
 subline_t line2(0,0,0); // never requires a copy or assignment.
}
</code></pre>

blocks|key|2038166|text|返回的类或结构可能被复制，也可能不被复制，这取决于编译器是否使用复制省略。简而言之，What+are+copy+elision+and+return+value+optimization?+的答案是，它是否被复制取决于许多事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2038167|当然，您可以通过返回引用来避免副本。在您的示例中，返回引用是无效的(尽管编译器会允许这样做)，因为本地结构是在堆栈上分配的，因此返回的引用是指已释放的对象。但是，如果对象被传递给您的函数(直接或作为对象的成员)，则可以安全地返回对它的引用，并避免返回时复制。|2038168|最后，如果您不能信任复制省略，并且希望避免复制，则可以使用并返回unique_ptr而不是引用。对象本身不会被复制，尽管unique_ptr本身可能被复制，也可能不被复制(同样，这取决于复制省略！)。然而，如果由于某些原因unique_ptr的复制省略没有发生，那么复制/移动unique_ptr是非常便宜的。|style|CODE|2038169|下面是一个使用unique_ptr的示例|2038170|#include+<memory>

struct+A+{
public:
++int+x;
++int+y;

++A(int+x,+int+y)+:+x(x),+y(y)+{
++}
};

std::unique_ptr<A>+returnsA()+{
++return+std::make_unique<A>(3,+4);
}

int+main()+{
++auto+a+=+returnsA();
}|code-block|syntax|javascript|2038171|请注意，您必须(遗憾地)为您的结构声明一个构造函数，否则由于C%2B%2B的不足，make_unique将无法编译。|2038172|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/12953127/what-are-copy-elision-and-return-value-optimization^0|16|1H|0|0|0|W|A|1O|A|33|A|3U|A|0|7|A|0|0|11|B|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|15|8|@$A|16|B|17|H|I]|$A|18|B|19|H|I]|$A|1A|B|1B|H|I]|$A|1C|B|1D|H|I]]|9|@]|C|$]]|$1|J|3|K|5|6|7|1E|8|@$A|1F|B|1G|H|I]]|9|@]|C|$]]|$1|L|3|M|5|N|7|1H|8|@]|9|@]|C|$O|P]]|$1|Q|3|R|5|6|7|1I|8|@$A|1J|B|1K|H|I]]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1L|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

The returned class or struct may or may not be copied, depending if the compiler uses copy elision. See the answers to <a href="https://stackoverflow.com/questions/12953127/what-are-copy-elision-and-return-value-optimization">What are copy elision and return value optimization?
</a> In short, whether it is copied or not depends on a number of things.

You can of course avoid a copy by returning a reference. In the case of your example, returning a reference is invalid (though the compiler will allow it) because the local struct is allocated on the stack, and therefor the returned reference refers to a deallocated object. However, if the object was passed to your function (directly or as a member of an object) you can safely return a reference to it and avoid copy-on-return.

Finally, if you cannot trust copy elision and you want to avoid copies, you can use and return a <code>unique_ptr</code> instead of a reference. The object itself will not be copied, although the <code>unique_ptr</code> itself may or may not be (again, depending on copy elision!). Copying/moving a <code>unique_ptr</code> is however very cheap if copy elision of the <code>unique_ptr</code> does not happen for some reason.

Here is an example using <code>unique_ptr</code>:

<pre><code>#include &lt;memory&gt;

struct A {
public:
 int x;
 int y;

 A(int x, int y) : x(x), y(y) {
 }
};

std::unique_ptr&lt;A&gt; returnsA() {
 return std::make_unique&lt;A&gt;(3, 4);
}

int main() {
 auto a = returnsA();
}
</code></pre>

Note that you must (unfortunately) declare a constructor for your struct, or else <code>make_unique</code> will not compile due to inadequacies of C++.

blocks|key|1824133|text|对于您定义的结构subline_t，是的，它将始终返回一个副本。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1824134|entityMap^0|8|9|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|$]]

For the structure <code>subline_t</code> you've defined, yes, it will always return a copy.

blocks|key|1824535|text|我不同意也不推荐返回向量来改变值:作为引用传递要快得多：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1824536|void+vectorial(vector+<double>+a,+vector+<double>+b,+vector+<double>+&c)
{
++++c[0]+=+a[1]+*+b[2]+-+b[1]+*+a[2];+c[1]+=+-a[0]+*+b[2]+%2B+b[0]+*+a[2];+c[2]+=+a[0]+*+b[1]+-+b[0]+*+a[1];
}
//This+is+slow!!!:
vector+<double>+vectorial(vector+<double>+a,+vector+<double>+b)
{
++++vector+<double>+c{+a[1]+*+b[2]+-+b[1]+*+a[2],+-a[0]+*+b[2]+%2B+b[0]+*+a[2],+a[0]+*+b[1]+-+b[0]+*+a[1]+};
++++return+c;
}|code-block|syntax|javascript|1824537|我在VS2015上进行了测试，在发布模式下的结果如下：|1824538|引用:8.01+MOPs，返回向量:+5.09+MOPs+60%25差！|1824539|在调试模式下，情况会更糟：|1824540|参考:0.053+MOPS，返回矢量:+0.034+MOPs|1824541|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I do not agree and NOT RECOMMEND to return vector to change values:
Is much faster pass as reference:

<pre><code>void vectorial(vector &lt;double&gt; a, vector &lt;double&gt; b, vector &lt;double&gt; &amp;c)
{
 c[0] = a[1] * b[2] - b[1] * a[2]; c[1] = -a[0] * b[2] + b[0] * a[2]; c[2] = a[0] * b[1] - b[0] * a[1];
}
//This is slow!!!:
vector &lt;double&gt; vectorial(vector &lt;double&gt; a, vector &lt;double&gt; b)
{
 vector &lt;double&gt; c{ a[1] * b[2] - b[1] * a[2], -a[0] * b[2] + b[0] * a[2], a[0] * b[1] - b[0] * a[1] };
 return c;
}
</code></pre>

I tested on VS2015 with following results in release mode:

By reference:8.01 MOPs and returning vector: 5.09 MOPs 60% worse!

In debug mode things are much worse:

By reference:0.053 MOPS and return vector: 0.034 MOPs

I am wondering about this because of scope issues. For example, consider the code

<pre><code>typedef struct {
 int x1;/*top*/
 int x2;/*bottom*/
 int id;
} subline_t;



subline_t subline(int x1, int x2, int id) {
 subline_t t = { x1, x2, id };
 return t;
}

int main(){
 subline_t line = subline(0,0,0); //is line garbage or isn't it? the reference
 //to subline_t t goes out of scope, so the only way this wouldn't be garbage
 //is if return copies
}
</code></pre>

So my question is, will the return statement always copy? In this case it seems to work, so I am led to believe that return does copy. If it does copy, will it copy in every case?

Does return statement copy values

数据结构

编译器

由于范围问题，我对此感到疑惑。例如，考虑下面的代码typedef struct {    int x1;/*top*/    int x2;/*bottom*/    int id;} subline_t;subline_t subline(int x1, int x2, int id) {    subline_t t = { x1, x2, id };    return t;}int mai

问是否返回语句复制值
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否返回语句复制值EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否返回语句复制值
EN