Skip to main content

copy elision and copy-and-swap idiom

An updated writeup of the copy-and-swap idiom is now available on the More C++ Idioms wikibook. A comparison of two different styles of assignment operator is shown. First version accepts the parameter as pass-by-const-reference whereas the second version accepts it as pass-by-value. For some classes pass-by-value turns out to be more efficient as a copy of the object is elided when the right hand side is a rvalue.

Comments

Maarten said…
Won't that not be less efficient once R-Value references make it into mainstream?
Mike said…
Thats actually pretty interesting and makes alot of sense, I need to put more thought into my programming and memory management/optimization.

Btw, that site is a great resource Im suprised this is the first time I've came across it. Thanks.
Anonymous said…
Strictly speaking, in that example since the code is inline, the compiler should be able to optimize out the temporary for rvalue references in both the

String &operator=(String)
and
String &operator=(const String &)

cases. But if it was not inline than the first would be better.

maarten - When rvalue reference types come in C++0x, it would be the same good as the copy-in version. However rvalue references let you do similar optimizations in more different scenarios.
Sumant said…
Hi anonymous! If you are absolutely sure about that, consider adding that (with some more explanation) in the original More C++ Idioms/copy-and-swap text at an appropriate place. After all, it is a wiki.
Anonymous said…
This copy-and-swap "idiom" is the most ridiculous, inane, incomprehensible thing I have ever heard. You're doing a freaking copy. Just do the copy. Use common sense. There's no need to swap back and forth. What the hell. This is an example of people being too smart for their own good, over-complicating a very basic operation.
Sumant said…
Hi anonymous! (2nd), I agree that copy-and-swap idiom requires a programmer to put more thought than one would ideally like to. If you ain't worried about exception-safety, use the solution that your common sense tells you. However, common sense can rarely be a substitute for such a well thought, useful, and widely (STL) deployed technique that has to work not just for oversmart people but for millions of C++ programmers out there.
elision said…
Thanks for sharing this interesting post.
elisions said…
Thanks for sharing this interesting post.
Eran Smith said…
Nice thing you found but is it work properly or it need some special programming tool??
xander345 said…
if you like c++ you can compile it online here: http://codecompiler.info/

32, 64 - windows & Linux - and more programming languages

Popular posts from this blog

Multi-dimensional arrays in C++11

What new can be said about multi-dimensional arrays in C++? As it turns out, quite a bit! With the advent of C++11, we get new standard library class std::array. We also get new language features, such as template aliases and variadic templates. So I'll talk about interesting ways in which they come together.

It all started with a simple question of how to define a multi-dimensional std::array. It is a great example of deceptively simple things. Are the following the two arrays identical except that one is native and the other one is std::array?

int native[3][4];
std::array<std::array<int, 3>, 4> arr;

No! They are not. In fact, arr is more like an int[4][3]. Note the difference in the array subscripts. The native array is an array of 3 elements where every element is itself an array of 4 integers. 3 rows and 4 columns. If you want a std::array with the same layout, what you really need is:

std::array<std::array<int, 4>, 3> arr;

That's quite annoying for two r…

Understanding Fold Expressions

C++17 has an interesting new feature called fold expressions. Fold expressions offer a compact syntax to apply a binary operation to the elements of a parameter pack. Here’s an example. template <typename... Args> auto addall(Args... args) { return (... + args); } addall(1,2,3,4,5); // returns 15. This particular example is a unary left fold. It's equivalent to ((((1+2)+3)+4)+5). It reduces/folds the parameter pack of integers into a single integer by applying the binary operator successively. It's unary because it does not explicitly specify an init (a.k.a. identity) argument. So, let add it. template <typename... Args> auto addall(Args... args) { return (0 + ... + args); } addall(1,2,3,4,5); // returns 15. This version of addall is a binary left fold. The init argument is 0 and it's redundant (in this case). That's because this fold expression is equivalent to (((((0+1)+2)+3)+4)+5). Explicit identity elements will come in handy a little la…

Folding Monadic Functions

In the previous two blog posts (Understanding Fold Expressions and Folding Functions) we looked at the basic usage of C++17 fold expressions and how simple functions can be folded to create a composite one. We’ll continue our stride and see how "embellished" functions may be composed in fold expressions.

First, let me define what I mean by embellished functions. Instead of just returning a simple value, these functions are going to return a generic container of the desired value. The choice of container is very broad but not arbitrary. There are some constraints on the container and once you select a generic container, all functions must return values of the same container. Let's begin with std::vector.
// Hide the allocator template argument of std::vector. // It causes problems and is irrelevant here. template <class T> struct Vector : std::vector<T> {}; struct Continent { }; struct Country { }; struct State { }; struct City { }; auto get_countries…