StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
18797537
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
3
CommunityOwnedDate
CreationDate
2013-09-14T01:55:35.903
FavoriteCount
0
LastActivityDate
2013-09-14T02:28:38.353
LastEditDate
2017-05-23T12:05:12.210
LastEditorUserId
-1
OwnerUserId
420683
ParentId
18797287
PostTypeId
2
Score
1
ViewCount
0
LastEditorDisplayName
text
Body
Note: I'm not very familiar with Java. There's a major difference between "variables" in C++ and Java: <pre><code>class X { public: int m = 5; }; X a; // no `= X();` required X b; a = b; a.m = 42; print(b.m); // this line is pseudo-code </code></pre> In Java, variables may point to different objects. In the example above, after the assignment, <code>a</code> and <code>b</code> point to the same object. Modifying this object through one will make the modification visible when accessing the object through the other, <code>print(b.m)</code> will print <code>42</code>. In C++, "variables" (actually: names) always refer to the same object. There are two objects, one named <code>a</code> and one named <code>b</code>, and the assignment doesn't change that. Per default/convention, assignment in C++ means (deep) copy. <code>a = b</code> will be interpreted by most people and in the case of built-in types as copy the contents of <code>b</code> to <code>a</code> (or, more formally, change <code>a</code> such that it will be equal to <code>b</code> afterwards, without altering <code>b</code>). Now it should be clear that you cannot alter which override of <code>worked</code> will be called by using the assignment in C++: which override of a virtual function is called is selected based on the type of the object (dynamic type), and you cannot change which object a name (variable) refers to. <hr> However, there are pointers in C++, so-called raw pointers and smart pointers. Pointers are objects themselves that point to other objects of one specific type. <code>X*</code> is a raw pointer that points to an object of type <code>X</code> even with polymorphism! Similarly, <code>std::shared_ptr<X></code> is a smart pointer that points to an object of type <code>X</code>. <pre><code>std::shared_ptr<X> pa = std::make_shared<X>(); std::shared_ptr<X> pb = std::make_shared<X>(); </code></pre> Every <code>make_shared</code> creates an object. So we have four objects in this example: <code>pa</code>, <code>pb</code>, and the two unnamed objects created via <code>make_shared</code>. For pointers, there are several operators for dealing with the object pointed to. The most important one is the asterisk, which dereferences the pointer. <code>*pa</code> will give you the object <code>pa</code> points to. The <code>pa-></code> operator is a shorthand for <code>(*pa).</code>, so you can use it to access members of the object pointed to. The assignment of pointers does not copy the object pointed to. After the assigment <code>pa = pb</code>, both will point to the same object. For smart pointers, that implies cleaning up objects that are not referred to any more: <pre><code>std::shared_ptr<X> pa = std::make_shared<X>(); std::shared_ptr<X> pb = std::make_shared<X>(); // 4 objects exist at this point pa = pb; // only 3 objects still exist, the one `pa` formerly pointed to was destroyed </code></pre> <hr> Polymorphism in C++ now works with either references (not explained here) or pointers. I said earlier that pointers can only point to one specific type of object. The crux is that this object might be part of a bigger object, e.g. via composition. But inheritance in C++ is very similar to composition: all the members of a base class become part of the base class subobject of a derived class' object: <pre><code>std::shared_ptr<Obj1> pobj1 = std::make_shared<Obj1>(); std::shared_ptr<Obj> pobj = pobj1; </code></pre> Here, <code>pobj</code> points to the <code>Obj</code> base class subobject within the object <code>*pobj1</code> (i.e. within the object <code>pobj1</code> points to). Polymorphism now works via virtual functions. Those have a special rule for which function is actually called. The expression <code>*pobj</code> gives us the object which <code>pobj</code> points to, and it is of type <code>Obj</code>. But in this example, it is only a base class subobject, i.e. the object we originally created is of a type derived from <code>Obj</code>. For these cases, we differentiate between the static and the dynamic type of an expression: <ul> <li>The static type of <code>*pobj</code> is always <code>Obj</code> - generally, for an object <code>p</code>, whose type is pointer to <code>some_type</code>, the static type of <code>*p</code> is just <code>some_type</code>, removing one level of indirection / one pointer to.</li> <li>The dynamic type of <code>*pobj</code> depends on which object <code>pobj</code> currently points to, and therefore generally is not known at compile-time. If the object is a base class subobject, we use the derived class object which it is part of, and recurse until the object we have is not a base class subobject any more. The type of the object we end up with is the dynamic type of the expression. In the example above, <code>pobj</code> points to the <code>Obj</code> base class subobject of <code>*pobj1</code>. The object <code>*pobj1</code> itself is not a base class subobject here, therefore the dynamic type of <code>*pobj</code> is <code>Obj1</code>.</li> </ul> This dynamic type is now used to select which virtual function override is called. In the case <code>pobj->worked()</code>, where the dynamic type of <code>*pobj</code> is <code>Obj1</code>, the override selected is <code>Obj1::worked</code>, which will return true. N.B. As <a href="https://stackoverflow.com/users/103167/ben-voigt">Ben Voigt</a> pointed out, the dynamic type does not depend on composition. It is only about inheritance.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POOverloading assignment operator in polymorphic classes
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USCommunity
UserOwnerUserId
1. USdyp
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POOverloading assignment operator in polymorphic classes
 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
 VTAcceptedByOriginator
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.