StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
16725030
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
4
CommunityOwnedDate
CreationDate
2013-05-23T22:38:07.250
FavoriteCount
0
LastActivityDate
2014-08-18T14:29:08.603
LastEditDate
2014-08-18T14:29:08.603
LastEditorUserId
1774667
OwnerUserId
1774667
ParentId
16724657
PostTypeId
2
Score
51
ViewCount
0
LastEditorDisplayName
text
Body
To understand why this is a good pattern, we should examine the alternatives, both in C++03 and in C++11. We have the C++03 method of taking a <code>std::string const&</code>: <pre><code>struct S { std::string data; S(std::string const& str) : data(str) {} }; </code></pre> in this case, there will always be a single copy performed. If you construct from a raw C string, a <code>std::string</code> will be constructed, then copied again: two allocations. There is the C++03 method of taking a reference to a <code>std::string</code>, then swapping it into a local <code>std::string</code>: <pre><code>struct S { std::string data; S(std::string& str) { std::swap(data, str); } }; </code></pre> that is the C++03 version of "move semantics", and <code>swap</code> can often be optimized to be very cheap to do (much like a <code>move</code>). It also should be analyzed in context: <pre><code>S tmp("foo"); // illegal std::string s("foo"); S tmp2(s); // legal </code></pre> and forces you to form a non-temporary <code>std::string</code>, then discard it. (A temporary <code>std::string</code> cannot bind to a non-const reference). Only one allocation is done, however. The C++11 version would take a <code>&&</code> and require you to call it with <code>std::move</code>, or with a temporary: this requires that the caller explicitly creates a copy outside of the call, and move that copy into the function or constructor. <pre><code>struct S { std::string data; S(std::string&& str): data(std::move(str)) {} }; </code></pre> Use: <pre><code>S tmp("foo"); // legal std::string s("foo"); S tmp2(std::move(s)); // legal </code></pre> Next, we can do the full C++11 version, that supports both copy and <code>move</code>: <pre><code>struct S { std::string data; S(std::string const& str) : data(str) {} // lvalue const, copy S(std::string && str) : data(std::move(str)) {} // rvalue, move }; </code></pre> We can then examine how this is used: <pre><code>S tmp( "foo" ); // a temporary `std::string` is created, then moved into tmp.data std::string bar("bar"); // bar is created S tmp2( bar ); // bar is copied into tmp.data std::string bar2("bar2"); // bar2 is created S tmp3( std::move(bar2) ); // bar2 is moved into tmp.data </code></pre> It is pretty clear that this 2 overload technique is at least as efficient, if not more so, than the above two C++03 styles. I'll dub this 2-overload version the "most optimal" version. Now, we'll examine the take-by-copy version: <pre><code>struct S2 { std::string data; S2( std::string arg ):data(std::move(x)) {} }; </code></pre> in each of those scenarios: <pre><code>S2 tmp( "foo" ); // a temporary `std::string` is created, moved into arg, then moved into S2::data std::string bar("bar"); // bar is created S2 tmp2( bar ); // bar is copied into arg, then moved into S2::data std::string bar2("bar2"); // bar2 is created S2 tmp3( std::move(bar2) ); // bar2 is moved into arg, then moved into S2::data </code></pre> If you compare this side-by-side with the "most optimal" version, we do exactly one additional <code>move</code>! Not once do we do an extra <code>copy</code>. So if we assume that <code>move</code> is cheap, this version gets us nearly the same performance as the most-optimal version, but 2 times less code. And if you are taking say 2 to 10 arguments, the reduction in code is exponential -- 2x times less with 1 argument, 4x with 2, 8x with 3, 16x with 4, 1024x with 10 arguments. Now, we can get around this via perfect forwarding and SFINAE, allowing you to write a single constructor or function template that takes 10 arguments, does SFINAE to ensure that the arguments are of appropriate types, and then moves-or-copies them into the local state as required. While this prevents the thousand fold increase in program size problem, there can still be a whole pile of functions generated from this template. (template function instantiations generate functions) And lots of generated functions means larger executable code size, which can itself reduce performance. For the cost of a few <code>move</code>s, we get shorter code and nearly the same performance, and often easier to understand code. Now, this only works because we know, when the function (in this case, a constructor) is called, that we will be wanting a local copy of that argument. The idea is that if we know that we are going to be making a copy, we should let the caller know that we are making a copy by putting it in our argument list. They can then optimize around the fact that they are going to give us a copy (by moving into our argument, for example). Another advantage of the 'take by value" technique is that often move constructors are noexcept. That means the functions that take by-value and move out of their argument can often be noexcept, moving any <code>throw</code>s out of their body and into the calling scope (who can avoid it via direct construction sometimes, or construct the items and <code>move</code> into the argument, to control where throwing happens). Making methods nothrow is often worth it.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POWhy do we copy then move?
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USYakk - Adam Nevraumont
UserOwnerUserId
1. USYakk - Adam Nevraumont
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. This table or related slice is empty.
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId
1. COI would also add if we know that we will make a copy, we should let the compiler do it, because the compiler always knows better.
 singulars
 PostPostId
 PO
 UserUserId
 USRayniery

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.