C++ Class Output [closed] - c++

Question

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center.
Closed 9 years ago.
i would love to understand how this one works!
if i have this code for example
class myclass
{
public :
int a;
myclass(){a=0; cout<<"first"<<endl;}
myclass(int i){a=i;cout<<"second"<<endl;}
~myclass(){cout<<a<<endl;}
};
class yourclass:protected myclass
{
int x;
myclass m1;
public:
myclass m2;
yourclass (int i): m2(3),myclass(i){x=i; a=7;}
}
and i'll make an object like this
yourclass ob1(5);
can you please explain how to works? how to calls constructors ?
Thank you

Answer 1

When you declare an object of a class myclass like this:
myclass ob1(5);
it means that you've created it with the second constructor which accepts int parameter. In other words, you literally called the second constructor. By the way the object is created on stack.
When you declare an object of a class myclass like this:
myclass ob1;
it means that you've created it with the first constructor which is parameterless. The right term for parameterless constructor is default constructor. In other words, you literally called the default (the first one) constructor. By the way the object is created on stack too (as in the previous case).
When objects are created on stack they are destructed automatically when the object goes out of scope. The notion of scope applies to the blocks of code which include functions/methods/blocks. You can easily distinguish the block by a pair of curly brackets {}. For example:
void function() {
myclass ob1;
} // <--- think of ob1 being destructed at this point
the object ob1 will go out of scope when function finishes execution and accordingly the destructor for ob1 is automatically called. Another example:
void function() {
while(true) {
myclass ob1;
} // <--- think of ob1 being destructed at this point
// ob1 does not exist here!
}
notice the infinite loop and the object ob1 created inside it on every iteration. You can clearly see that curly brackets define a block which can combine multiple statements that constitute each iteration (currently there is only 1 statement). Accordingly, the object ob1 will be automatically destructed in the end of each iteration.
The notion of scope applies to class members too. For instance, say you have a class wrapper, and you declare myclass as its member (m1) in the following way:
class wrapper {
public:
myclass m1;
};
Then lets take one of the previous examples and create an object of wrapper on stack:
void function() {
wrapper w;
} // <--- destructor of w called first, destructor of w.m1 is called after
First the execution of the default constructor of w is started, during which w.m1 is created (with default constructor in this case because I didn't specify in the constructor of w which constructor of w.m1 I'd like to call). Then the constructor of w finishes the execution, and w can be deemed as officially created. The execution of function continues.
When function finishes execution, w goes out of scope, and as you remember its destructor is called automatically then. As soon as the destructor of w finishes the execution, the destructor of w.m1 is automatically called too. You can think of it as the object w has its own internal scope while it's alive, and a soon as it dies, all of its members go out of scope and should die too.

Answer 2

Ok, let's take it easy and analyze it step by step.
First class
class myclass {
public :
int a;
myclass(){a=0; cout<<"first"<<endl;}
myclass(int i){a=i;cout<<"second"<<endl;}
~myclass(){cout<<a<<endl;}
};
Here we are defining a class myclass which have a single member variable a of type int. It declares a default constructor (with no arguments) which assigns to a, 0 and then proceed to print first.
We also have a one-parameter constructor that initialize a to that first parameter, and prints second, and a destructor which simply prints the value of the member variable a before deallocating it.
Initialization list
Now, within constructors you can define an initialization list which is on the form
<class name>(...) a(x), b(y), c(z), ... {}
// ^^^^^^^^^^^^^^^^^^^^^
This initialization list is necessary when there's no default constructor available for the type of any member variable of the class. Suppose we create a nogood class without a default constructor and define our main class to have a member of type nogood, how would he initialize that member variable? You can expect it to wait until the constructor body is executed.
Second class
class yourclass : protected myclass {
int x;
myclass m1;
public:
myclass m2;
yourclass (int i): m2(3),myclass(i){x=i; a=7;}
};
Now yourclass inherits protected from myclass. What does it means? It means that whatever in myclass is public or protected, will be protected in yourclass (whatever is private will still be private).
The class yourclass defines two private members x and m1 and one public member m2. It doesn't define any default constructor for it and defines a single parameter constructor instead (that can actually be also used to implicitly convert an int to yourclass if required).
Output: constructors
Firstly it calls the protected sub object's constructor producing second.
Then, since we haven't initialize m1 explicitly, it will initialize it with the default constructor producing the output first.
Finally in the constructor we initialize m2(3) which is of type myclass which will call myclass::myclass(int) producing second as output. So the output is:
second
first
second
Output: destructors
Now for the destructors calls, it will call the destructors for each member variables in the reverse order to their initialization. The order of initialization was: m1, m2. The reverse order is m2, m1. m2 was initialized with 3 in the initialize list, m1 was initialized to 0 by default. Then finally it calls the ob1 destructor which was initialized to 7. Therefore the final output is:
second
first
second
3
0
7