Comments on: Efficient argument passing in C++11, Part 1 https://codesynthesis.com/~boris/blog//2012/06/19/efficient-argument-passing-cxx11-part1/ Boris Kolpackov's blog about software Sun, 05 Apr 2026 20:49:35 +0000 http://wordpress.org/?v=2.2.2 By: Boris Kolpackov https://codesynthesis.com/~boris/blog//2012/06/19/efficient-argument-passing-cxx11-part1/#comment-2103 Boris Kolpackov Wed, 20 Jun 2012 14:01:47 +0000 https://codesynthesis.com/~boris/blog//2012/06/19/efficient-argument-passing-cxx11-part1/#comment-2103 CM, you are talking about copy elision/[N]RVO optimizations that C++ compilers are allowed (but not required or always capable) to do. So without the move semantics, whether f(g()) will be optimal depends on f() and g()'s implementations, which C++ compiler you are using, optimization level, whether the moon is in the right phase, and who knows what else. On the other hand, support for the move semantics is mandated by the standard so you can be sure that with a conforming C++11 compiler f(g()) will cost nor more than 2 move constructor calls. CM, you are talking about copy elision/[N]RVO optimizations that C++ compilers are allowed (but not required or always capable) to do. So without the move semantics, whether f(g()) will be optimal depends on f() and g()’s implementations, which C++ compiler you are using, optimization level, whether the moon is in the right phase, and who knows what else.

On the other hand, support for the move semantics is mandated by the standard so you can be sure that with a conforming C++11 compiler f(g()) will cost nor more than 2 move constructor calls.

]]> By: CM https://codesynthesis.com/~boris/blog//2012/06/19/efficient-argument-passing-cxx11-part1/#comment-2095 CM Tue, 19 Jun 2012 15:13:12 +0000 https://codesynthesis.com/~boris/blog//2012/06/19/efficient-argument-passing-cxx11-part1/#comment-2095 Dude, for f(g()) to be efficient g's return type does not need to be moveable. returning value from function does not involve copy (unless your compiler is belongs to a garbage collection) nor does passing rvalue by value. T g() { return T(...); } voif f(T v) { ... } f(g()); is equally efficient in both C++03 and C++11. And it is achieved essentially by wise choice of memory address where given value is going to be constructed. Move-and-init semantic is just a trick that allows you to move value from one address to another explicitly (which is required when std::vector moves stuff around). Dude, for f(g()) to be efficient g’s return type does not need to be moveable. returning value from function does not involve copy (unless your compiler is belongs to a garbage collection) nor does passing rvalue by value.

T g() { return T(…); }
voif f(T v) { … }

f(g()); is equally efficient in both C++03 and C++11. And it is achieved essentially by wise choice of memory address where given value is going to be constructed. Move-and-init semantic is just a trick that allows you to move value from one address to another explicitly (which is required when std::vector moves stuff around).

]]>