StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
5481588
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
8
CommunityOwnedDate
2011-03-30T20:57:32.847
CreationDate
2011-03-30T03:36:55.843
FavoriteCount
0
LastActivityDate
2017-07-31T12:56:38.057
LastEditDate
2017-07-31T12:56:38.057
LastEditorUserId
5771029
OwnerUserId
530189
ParentId
5481539
PostTypeId
2
Score
549
ViewCount
0
LastEditorDisplayName
text
Body
It declares an <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1690.html" rel="noreferrer">rvalue reference</a> (standards proposal doc). Here's an introduction to rvalue <a href="http://www.artima.com/cppsource/rvalue.html" rel="noreferrer">references</a>. Here's a fantastic in-depth look at rvalue references by one of Microsoft's standard library <a href="http://blogs.msdn.com/b/vcblog/archive/2009/02/03/rvalue-references-c-0x-features-in-vc10-part-2.aspx" rel="noreferrer">developers</a>. (But see the Caution in the comments following this answer before reading this article.) The biggest difference between a C++03 reference (now called an lvalue reference in C++11) is that it can bind to an rvalue like a temporary without having to be const. Thus, this syntax is now legal: <pre><code>T&& r = T(); </code></pre> rvalue references primarily provide for the following: Move semantics. A move constructor and move assignment operator can now be defined that takes an rvalue reference instead of the usual const-lvalue reference. A move functions like a copy, except it is not obliged to keep the source unchanged; in fact, it usually modifies the source such that it no longer owns the moved resources. This is great for eliminating extraneous copies, especially in standard library implementations. For example, a copy constructor might look like this: <pre><code>foo(foo const& other) { this->length = other.length; this->ptr = new int[other.length]; copy(other.ptr, other.ptr + other.length, this->ptr); } </code></pre> If this constructor was passed a temporary, the copy would be unnecessary because we know the temporary will just be destroyed; why not make use of the resources the temporary already allocated? In C++03, there's no way to prevent the copy as we cannot determine we were passed a temporary. In C++11, we can overload a move constructor: <pre><code>foo(foo&& other) { this->length = other.length; this->ptr = other.ptr; other.length = 0; other.ptr = nullptr; } </code></pre> Notice the big difference here: the move constructor actually modifies its argument. This would effectively "move" the temporary into the object being constructed, thereby eliminating the unnecessary copy. The move constructor would be used for temporaries and for non-const lvalue references that are explicitly converted to rvalue references using the <code>std::move</code> function (it just performs the conversion). The following code both invoke the move constructor for <code>f1</code> and <code>f2</code>: <pre><code>foo f1((foo())); // Move a temporary into f1; temporary becomes "empty" foo f2 = std::move(f1); // Move f1 into f2; f1 is now "empty" </code></pre> Perfect forwarding. rvalue references allow us to properly forward arguments for templated functions. Take for example this factory function: <pre><code>template <typename T, typename A1> std::unique_ptr<T> factory(A1& a1) { return std::unique_ptr<T>(new T(a1)); } </code></pre> If we called <code>factory<foo>(5)</code>, the argument will be deduced to be <code>int&</code>, which will not bind to a literal 5, even if <code>foo</code>'s constructor takes an <code>int</code>. Well, we could instead use <code>A1 const&</code>, but what if <code>foo</code> takes the constructor argument by non-const reference? To make a truly generic factory function, we would have to overload factory on <code>A1&</code> and on <code>A1 const&</code>. That might be fine if factory takes 1 parameter type, but each additional parameter type would multiply the necessary overload set by 2. That's very quickly unmaintainable. rvalue references fix this problem by allowing the standard library to define a <code>std::forward</code> function that can properly forward lvalue/rvalue references. For more information about how <code>std::forward</code> works, see <a href="https://stackoverflow.com/a/3582313/530189">this excellent answer</a>. This enables us to define the factory function like this: <pre><code>template <typename T, typename A1> std::unique_ptr<T> factory(A1&& a1) { return std::unique_ptr<T>(new T(std::forward<A1>(a1))); } </code></pre> Now the argument's rvalue/lvalue-ness is preserved when passed to <code>T</code>'s constructor. That means that if factory is called with an rvalue, <code>T</code>'s constructor is called with an rvalue. If factory is called with an lvalue, <code>T</code>'s constructor is called with an lvalue. The improved factory function works because of one special rule: <blockquote> When the function parameter type is of the form <code>T&&</code> where <code>T</code> is a template parameter, and the function argument is an lvalue of type <code>A</code>, the type <code>A&</code> is used for template argument deduction. </blockquote> Thus, we can use factory like so: <pre><code>auto p1 = factory<foo>(foo()); // calls foo(foo&&) auto p2 = factory<foo>(*p1); // calls foo(foo const&) </code></pre> Important rvalue reference properties: <ul> <li>For overload resolution, lvalues prefer binding to lvalue references and rvalues prefer binding to rvalue references. Hence why temporaries prefer invoking a move constructor / move assignment operator over a copy constructor / assignment operator.</li> <li>rvalue references will implicitly bind to rvalues and to temporaries that are the result of an implicit conversion. i.e. <code>float f = 0f; int&& i = f;</code> is well formed because float is implicitly convertible to int; the reference would be to a temporary that is the result of the conversion.</li> <li>Named rvalue references are lvalues. Unnamed rvalue references are rvalues. This is important to understand why the <code>std::move</code> call is necessary in: <code>foo&& r = foo(); foo f = std::move(r);</code></li> </ul>
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POWhat does T&& (double ampersand) mean in C++11?
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. This table or related slice is empty.
UserOwnerUserId
1. USPeter Huene
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POWhat does T&& (double ampersand) mean in C++11?
 singulars
 PostTypePostTypeId
 PTQuestion
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

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.