如果将 function 返回值传递给 function 引用参数，那么 C++ 会发生什么？

Question

Let's consider two functions:

//Test functions
Object MakeObj(){/* processsing */};
Object ChangeObj(const Object& obj){/* processsing */};
//Then execute
Object test_obj = ChangeObj(MakeObj());

1. Is the execution safe?

2. Where is stored the 'Object' return value of the MakeObj()? Can I use a reference to that storage?

3. Or a temporary variable is necessary:

    Object MakeObj(){/* processsing */}; Object ChangeObj(const Object& obj){/* processsing */}; Object tmp_obj = MakeObj(); Object test_obj = ChangeObj(tmp_obj);

4. Is there any performance gain or it is exactly the same, if the code from point 3 gets changed:

    Object MakeObj(){/* processsing */}; Object ChangeObj(Object obj){/* processsing */}; //No reference here, so 'Object' value is created. Object test_obj = ChangeObj(MakeObj());

5. Is there a way to use "move" to avoid coping a big Object? Eg:

    Object ChangeObj(Object&& obj){/* processsing */};

   If yes, how it would look like?

6. What would be the fastest implementation (as less coping as possible) of those two functions above? Assumption: "Object MakeObj();" declaration cannot be changed.

Answer 1

1. Execution is safe because const reference extends object lifetime (or here )

2. The object itself is stored somewhere on the stack, but it will not be erased as long as the const reference exists( compare asm line 20(non-reference) and 25-27(const reference))

3. No. It isn't necessary.

4. In the general case, the code from point 4 is faster, even if there was a move (in the case of a vector , optimization for 2-3 assignment operations size_t )

5. move can only be applied in the code from point 3, and then it will look like

Object MakeObj(){/* processsing */};
Object ChangeObj(Object&& obj){/* processsing */};
Object tmp_obj = MakeObj();
Object test_obj = ChangeObj(std::move(tmp_obj));
//here tmp_obj is no longer valid

6. Code from point 4 should be the fastest, but MEASURE:!! And remember about first rule of optimization: Don't optimize prematurely