StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
2880326
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
6
CommunityOwnedDate
CreationDate
2010-05-21T07:39:04.157
FavoriteCount
0
LastActivityDate
2011-06-27T13:15:54.067
LastEditDate
2011-06-27T13:15:54.067
LastEditorUserId
500104
OwnerUserId
140719
ParentId
2878972
PostTypeId
2
Score
6
ViewCount
0
LastEditorDisplayName
text
Body
To paraphrase our question: <blockquote> why do we have to write <code>Date(const Date &)</code> instead of <code>Date(Date)</code>? </blockquote> I'm going to split this into two parts, the first answering why a copy constructor needs to take its argument per reference, the second why this needs to be a const reference. <hr> The reason a copy constructor needs to take its argument per reference is that, for a function that's taking an argument per copy <code>void f(T arg)</code>, when you call it <code>f(obj)</code>, <code>obj</code> is copied into <code>arg</code> using <code>T</code>'s copy constructor. So if you want to implement the copy constructor, you'd better not take the argument by copy, because this would call the copy constructor while invoking it, leading to an endless recursion. You can easily try this yourself: <pre><code>struct tester { tester(tester) {std::cout << "inside of erroneous copy ctor\n";} }; int main() { tester t1; std::cout << "about to call erroneous copy ctor\n"; tester t2(t1); std::cout << "done with call erroneous copy ctor\n"; return 0; } </code></pre> That program should only ever write one line and then blow the stack. Note: As Dennis points out in his comment, actually this program is not guaranteed to compile, so, depending on your compiler, you might not really be able to try it. Bottom line: A copy constructor should take its argument by reference, because taking it per copy would require the copy constructor. <hr> That leaves the question of why it is <code>const T&</code> and not simply <code>T&</code>? In fact, there are two reasons for that. The logical reason is that, when you invoke the copy constructor, you do not expect the object copied from to change. In C++, if you want to express that something is immutable, you use <code>const</code>. This tells users that they can safely pass their precious objects to your copy constructor, because it won't do anything with it except read from it. As a nice side effect, if you implement the copy constructor and accidentally try to write to the object, the compiler throws an error message at you, reminding you of the promise made to the caller. The other reason is that you cannot bind temporary objects to non-<code>const</code> references, you can only bind them to <code>const</code> references. A temporary object is, for example, what a function might return: <pre><code>struct tester { tester(tester& rhs) {std::cout << "inside of erroneous copy ctor\n";} }; tester void f() { tester t; return t; } </code></pre> When <code>f()</code> is called, a <code>tester</code> object is created inside, and a copy of it is then returned to the caller, which might then put it into another copy: <pre><code>tester my_t = f(); // won't compile </code></pre> The problem is that <code>f()</code> returns a temporary object, and in order to call the copy constructor, this temporary would need to bind to the <code>rhs</code> argument of <code>tester</code>'s copy constructor, which is a non-<code>const</code> reference. But you cannot bind a temporary object to a non-<code>const</code> reference, so that code won't compile. While you can work around this if you want (just don't copy the temporary, but bind it to a <code>const</code> reference instead, which extends the temporary's lifetime to the end of the reference's lifetime: <code>const tester& my_t = f()</code>), people expect to be able to copy temporaries of your type. Bottom line: A copy constructor should take its argument by const reference, because otherwise users might not be willing or able to use it. <hr> Here's one more fact: In the next C++ standard, you can overload functions for temporary objects, so-called <code>rvalues</code>. So you can have a special copy constructor that takes temporary objects overloading the "normal" copy constructor. If you have a compiler that already supports this new feature, you can try it out: <pre><code>struct tester { tester(const tester& rhs) { std::cout << "common copy ctor\n"; } tester( tester&& rhs) { std::cout << "copy ctor for rvalues\n"; } }; </code></pre> When you use the above code to invoke our <code>f()</code> <pre><code>tester my_t = f(); </code></pre> the new copy constructor for rvalues should be called when the temporary object returned by the call to <code>f()</code> is copied to <code>my_t</code> and the regular copy constructor might be called in order to copy the <code>t</code> object from inside of <code>f()</code> to the returned temporary. (Note: you might have to disable your compiler's optimization in order to see this, as the compiler is allowed to optimize away all the copying.) So what can you with this? Well, when you copy an rvalue, you know that the object copied from is going to be destroyed after the call to the copy constructor, so the copy constructor taking an rvalue (<code>T&&</code>) could just steal the values from the argument instead of copying them. Since the object is going to be destroyed anyway, nobody is going to notice. For some classes (for example, for string classes), moving the value from one object to another could be much cheaper than copying them. 
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POwhy do we have to send the const " type " reference instead of just the types name to the constructor
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USXeo
UserOwnerUserId
1. USsbi
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POwhy do we have to send the const " type " reference instead of just the types name to the constructor
 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.