StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
8114913
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
19
CommunityOwnedDate
CreationDate
2011-11-13T21:32:58.480
FavoriteCount
0
LastActivityDate
2015-05-03T12:01:19.040
LastEditDate
2015-05-03T12:01:19.040
LastEditorUserId
257299
OwnerUserId
734069
ParentId
8114276
PostTypeId
2
Score
694
ViewCount
0
LastEditorDisplayName
text
Body
Here are the possible ways to take a unique pointer as an argument, as well as their associated meaning. <h3>(A) By Value</h3> <pre><code>Base(std::unique_ptr<Base> n) : next(std::move(n)) {} </code></pre> In order for the user to call this, they must do one of the following: <pre><code>Base newBase(std::move(nextBase)); Base fromTemp(std::unique_ptr<Base>(new Base(...)); </code></pre> To take a unique pointer by value means that you are transferring ownership of the pointer to the function/object/etc in question. After <code>newBase</code> is constructed, <code>nextBase</code> is guaranteed to be empty. You don't own the object, and you don't even have a pointer to it anymore. It's gone. This is ensured because we take the parameter by value. <code>std::move</code> doesn't actually move anything; it's just a fancy cast. <code>std::move(nextBase)</code> returns a <code>Base&&</code> that is an r-value reference to <code>nextBase</code>. That's all it does. Because <code>Base::Base(std::unique_ptr<Base> n)</code> takes its argument by value rather than by r-value reference, C++ will automatically construct a temporary for us. It creates a <code>std::unique_ptr<Base></code> from the <code>Base&&</code> that we gave the function via <code>std::move(nextBase)</code>. It is the construction of this temporary that actually moves the value from <code>nextBase</code> into the function argument <code>n</code>. <h3>(B) By non-const l-value reference</h3> <pre><code>Base(std::unique_ptr<Base> &n) : next(std::move(n)) {} </code></pre> This has to be called on an actual l-value (a named variable). It cannot be called with a temporary like this: <pre><code>Base newBase(std::unique_ptr<Base>(new Base)); //Illegal in this case. </code></pre> The meaning of this is the same as the meaning of any other use of non-const references: the function may or may not claim ownership of the pointer. Given this code: <pre><code>Base newBase(nextBase); </code></pre> There is no guarantee that <code>nextBase</code> is empty. It may be empty; it may not. It really depends on what <code>Base::Base(std::unique_ptr<Base> &n)</code> wants to do. Because of that, it's not very evident just from the function signature what's going to happen; you have to read the implementation (or associated documentation). Because of that, I wouldn't suggest this as an interface. <h3>(C) By const l-value reference</h3> <pre><code>Base(std::unique_ptr<Base> const &n); </code></pre> I don't show an implementation, because you cannot move from a <code>const&</code>. By passing a <code>const&</code>, you are saying that the function can access the <code>Base</code> via the pointer, but it cannot store it anywhere. It cannot claim ownership of it. This can be useful. Not necessarily for your specific case, but it's always good to be able to hand someone a pointer and know that they cannot (without breaking rules of C++, like no casting away <code>const</code>) claim ownership of it. They can't store it. They can pass it to others, but those others have to abide by the same rules. <h3>(D) By r-value reference</h3> <pre><code>Base(std::unique_ptr<Base> &&n) : next(std::move(n)) {} </code></pre> This is more or less identical to the "by non-const l-value reference" case. The differences are two things. <ol> <li>You can pass a temporary: <pre><code>Base newBase(std::unique_ptr<Base>(new Base)); //legal now.. </code></pre></li> <li>You must use <code>std::move</code> when passing non-temporary arguments.</li> </ol> The latter is really the problem. If you see this line: <pre><code>Base newBase(std::move(nextBase)); </code></pre> You have a reasonable expectation that, after this line completes, <code>nextBase</code> should be empty. It should have been moved from. After all, you have that <code>std::move</code> sitting there, telling you that movement has occurred. The problem is that it hasn't. It is not guaranteed to have been moved from. It may have been moved from, but you will only know by looking at the source code. You cannot tell just from the function signature. <h3>Recommendations</h3> <ul> <li>(A) By Value: If you mean for a function to claim ownership of a <code>unique_ptr</code>, take it by value.</li> <li>(C) By const l-value reference: If you mean for a function to simply use the <code>unique_ptr</code> for the duration of that function's execution, take it by <code>const&</code>. Alternatively, pass a <code>&</code> or <code>const&</code> to the actual type pointed to, rather than using a <code>unique_ptr</code>.</li> <li>(D) By r-value reference: If a function may or may not claim ownership (depending on internal code paths), then take it by <code>&&</code>. But I strongly advise against doing this whenever possible.</li> </ul> <h3>How to manipulate unique_ptr</h3> You cannot copy a <code>unique_ptr</code>. You can only move it. The proper way to do this is with the <code>std::move</code> standard library function. If you take a <code>unique_ptr</code> by value, you can move from it freely. But movement doesn't actually happen because of <code>std::move</code>. Take the following statement: <pre><code>std::unique_ptr<Base> newPtr(std::move(oldPtr)); </code></pre> This is really two statements: <pre><code>std::unique_ptr<Base> &&temporary = std::move(oldPtr); std::unique_ptr<Base> newPtr(temporary); </code></pre> (note: The above code does not technically compile, since non-temporary r-value references are not actually r-values. It is here for demo purposes only). The <code>temporary</code> is just an r-value reference to <code>oldPtr</code>. It is in the constructor of <code>newPtr</code> where the movement happens. <code>unique_ptr</code>'s move constructor (a constructor that takes a <code>&&</code> to itself) is what does the actual movement. If you have a <code>unique_ptr</code> value and you want to store it somewhere, you must use <code>std::move</code> to do the storage.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POHow do I pass a unique_ptr argument to a constructor or a function?
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USkevinarpe
UserOwnerUserId
1. USNicol Bolas
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POHow do I pass a unique_ptr argument to a constructor or a function?
 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.