StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
6962492
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
2
CommunityOwnedDate
CreationDate
2011-08-05T20:52:01.363
FavoriteCount
0
LastActivityDate
2011-08-05T20:58:12.547
LastEditDate
2011-08-05T20:58:12.547
LastEditorUserId
560648
OwnerUserId
560648
ParentId
6928913
PostTypeId
2
Score
1
ViewCount
0
LastEditorDisplayName
text
Body
<h2>Short answer</h2> That is a constructor with an empty body, and a member initialisation list that initialises two data members to the value <code>0</code>. i.e. <ul> <li><code>class-name([ ctor-args ]) [ : member-init-list ] { [ ctor-body ] }</code></li> <li>where <code>member-init-list</code> is <code>member-name(args) [, member-name(args) [, ... ] ]</code>.</li> </ul> (Note: not actual C++ lexical grammar constructions) <hr> <h2>Long answer</h2> <h3>Background</h3> Take the following class definitions: <pre><code>struct Base {}; struct Derived : Base {}; </code></pre> You may already be aware that <code>Derived</code> derives from <code>Base</code>. You may also already be aware that <code>Derived</code> and <code>Base</code> both have a synthesised (implicitly-declared) default (takes no arguments) constructor. <code>Derived</code>'s constructor implicitly/automatically invokes <code>Base</code>'s. Now let's add a basic member function: <pre><code>struct Derived : Base { void foo() {} }; </code></pre> I have both declared and defined this member function <code>foo</code>; its body is empty, so nothing happens when you invoke it. This is pretty pointless, but it's perfectly valid. Now, instead, let's make our own constructor: <pre><code>struct Derived : Base { Derived() {} }; </code></pre> This looks more familiar. It's still a [special] function with an empty body, and the <code>Base</code> constructor is still being implicitly invoked. We haven't changed that. <hr> <h3>Handling data members</h3> Let's add some data members and set their value in our constructor: <pre><code>struct Derived : Base { Derived() { x = 0; y = 0; } int x, y; }; </code></pre> Both <code>x</code> and <code>y</code> will have the value <code>0</code> after object construction. This is still fundamental C++. But what you may not be aware of is that you are not initialising these data members. You are merely assigning to them after the possibility of initialising them. In fact, data members of built-in types are not implicitly initialised, so let's pick a better example: <pre><code>struct Derived : Base { Derived() /* HERE */ { x = ""; y = ""; } std::string x, y; }; </code></pre> <code>x</code> and <code>y</code> are implicitly initialised before the code in the constructor body runs. When the constructor body starts to run, all members that will be initialised, have already been initialised, and the base constructor has been implicitly invoked. We can intercept this behaviour and provide our own initialisation values by writing a member initialiser list in the place where I wrote <code>/* HERE */</code> in the previous snippet. With the member initialiser list, the snippet looks like this: <pre><code>struct Derived : Base { Derived() : x(""), y("") { x = ""; y = ""; } std::string x, y; }; </code></pre> Wow! OK; now we're initialising the strings to <code>""</code>, and later assigning the same, empty value to them in the constructor body. We can get rid of those assignments, then: <pre><code>struct Derived : Base { Derived() : x(""), y("") {} std::string x, y; }; </code></pre> Now the constructor body is empty, but the constructor still does stuff. It implicitly invokes the base constructor, and it explicitly initialises the data members <code>x</code> and <code>y</code> to the empty string. And, because <code>std::string</code> has a default constructor that does the same, we can write for short: <pre><code>struct Derived : Base { Derived() : x(), y() {} std::string x, y; }; </code></pre> Going back to your original example, this applies to objects of built-in types just as easily. Let's consider two pointers: <pre><code>struct Derived : Base { Derived() : next(0), prev(0) {} Derived* next; Derived* prev; }; </code></pre> <hr> <h3>Handling base classes</h3> And, as an added bonus, we can use the member initialisation list to invoke the base constructor explicitly: <pre><code>struct Derived : Base { Derived() : Base(), next(0), prev(0) {} Derived* next; Derived* prev; }; </code></pre> This is pretty pointless unless the base constructor wants some arguments: <pre><code>struct Base { Base(int x) {} }; struct Derived : Base { Derived() : Base(0), next(0), prev(0) {} Derived* next; Derived* prev; }; </code></pre> <hr> I hope that this has been useful.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POExplain blank class functions in C++
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USLightness Races in Orbit
UserOwnerUserId
1. USLightness Races in Orbit
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POExplain blank class functions in C++
 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
 VTAcceptedByOriginator
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId
1. COThanks for your patience in explaining this, this was the most helpful and covering things in details.
 singulars
 PostPostId
 PO
 UserUserId
 USlinuxeasy
2. CO@linuxeasy: Not a problem.
 singulars
 PostPostId
 PO
 UserUserId
 USLightness Races in Orbit

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.