InnerClass object being a member of OuterClass object is created twice - c++

Question

I have two classes: OuterClass and InnerClass. InnerClass is a private member of OuterClass and should be created in OuterClass constructor with an InnerClass(int) constructor, however the default InnerClass constructor is still called.
InnerClass.hpp:
#ifndef INNERCLASS_HPP_
#define INNERCLASS_HPP_
class InnerClass {
public:
int a;
InnerClass();
InnerClass(int);
~InnerClass();
};
#endif /* INNERCLASS_HPP_ */
InnerClass.cpp:
#include "InnerClass.hpp"
#include <iostream>
InnerClass::InnerClass() {
a = 1;
std::cout << "inner class constructed, a = " << a << std::endl;
}
InnerClass::InnerClass(int x) {
a = x;
std::cout << "inner class constructed, a = " << a << std::endl;
//automatically: object InnerClass (a=3) is destroyed here...
}
InnerClass::~InnerClass() {
std::cout << "inner class destructed, a = " << a << std::endl;
}
OuterClass.hpp:
#ifndef OUTERCLASS_HPP_
#define OUTERCLASS_HPP_
#include "InnerClass.hpp"
class OuterClass {
private:
InnerClass blah;
public:
OuterClass();
~OuterClass();
void doSth();
};
#endif /* OUTERCLASS_HPP_ */
OuterClass.cpp:
#include "OuterClass.hpp"
#include <iostream>
OuterClass::OuterClass() {
// automatically: blah = InnerClass();
std::cout << "outer class constructing started, blah.a = " << blah.a << std::endl;
blah = InnerClass(3);
std::cout << "outer class constructed" << std::endl;
}
OuterClass::~OuterClass() {
std::cout << "outer class destructed" << std::endl;
}
void OuterClass::doSth() {
std::cout << "doSth: " << blah.a << std::endl;
}
main:
#include "OuterClass.hpp"
#include <iostream>
int main(int argc, char** argv) {
std::cout << "Compiled at " << __TIME__ << std::endl;
OuterClass x = OuterClass();
x.doSth();
std::cout << "done" << std::endl;
}
output:
Compiled at 12:11:12
inner class constructed, a = 1 //this is unexpected
outer class constructing started, blah.a = 1 //this should be random data
inner class constructed, a = 3
inner class destructed, a = 3 //this is unexpected
outer class constructed
doSth: 3
done
outer class destructed
inner class destructed, a = 3
Questions:
Why is the default constructor of InnerClass called at the start of OuterClass constructor?
What and why is destructed in OuterClass constructor ("inner class destructed, a = 3 //this is unexpected")?
It seems that InnerClass object with a = 3 was destructed in the OuterClass constructor, than why does method doSth() return 3 instead of random data?
Why does removing an InnerClass() constructor (from both InnerClass.hpp and InnerClass.cpp files) result in compile-time error at the OuterClass constructor in OuterClass.cpp file? The error says that no InnerClass() definition found.

Answer 1

Use initializer-list in constructor.
OuterClass::OuterClass() : blah(3) {
// automatically: blah = InnerClass();
std::cout << "outer class constructing started, blah.a = " << blah.a << std::endl;
std::cout << "outer class constructed" << std::endl;
}
Since when you use
OuterClass::OuterClass() {
// automatically: blah = InnerClass();
std::cout << "outer class constructing started, blah.a = " << blah.a << std::endl;
blah = InnerClass(3);
std::cout << "outer class constructed" << std::endl;
}
firstly for initialize blah will be called default c-tor and in blah = InnerClass(3);, that creates temporary object and copy it to blah, after this string will be called destructor of temporary object.

Answer 2

1) Why is the default constructor of InnerClass called at the start of OuterClass constructor?
To construct blah.
2) What and why is destructed in OuterClass constructor ("inner class destructed, a = 3 //this is unexpected")?
The InnerClass(3) you constructed in the second line of the constructor. The one you used to hold the value you assigned to blah. It is destructed because it goes out of scope once the assignment to blah is complete.
3) It seems that InnerClass object with a = 3 was destructed in the OuterClass constructor, than why does method doSth() return 3 instead of random data?
Because you assigned the value 3 to blah. Your code reads;
blah = InnerClass(3);
This creates an InnerClass with the value 3 and then copies its value to blah. So both blah and this temporary object have the same value. The temporary is then destroyed.
If you think about it, there is no other sensible way to implement this line of code.
4) Why does removing an InnerClass() constructor (from both InnerClass.hpp and InnerClass.cpp files) result in compile-time error at the OuterClass constructor in OuterClass.cpp file? The error says that no InnerClass() definition found.
Because then you have no way to construct blah in the first place. (As others have pointed out, you probably wanted an initializer list to construct blah right in the first place rather than default constructing it and then having to go to contortions to fix it.)

Answer 3

OuterClass::OuterClass() /* default blah constructor is called here */ {
std::cout << "outer class constructing started, blah.a = " << blah.a << std::endl;
blah = InnerClass(3); /* a temporary InnerClass is created */
std::cout << "outer class constructed" << std::endl;
} //temporary InnerClass destroyed (out of scope)
Use initializer list to prevent calling default constructor as ForEveR suggests

Answer 4

When the constructor of OuterClass starts executing the body, all members must be constructed. Since there is a blah InnerClass member, it got constructed.
When you assign to blah in OuterClass::OuterClass(), there is a temporary instance created. Here's the order of things:
A temporary InnerClass(3) is constructed.
It is assigned to blah.
The temporary value is destructed -- that's why there's a destructor call.
Follows from 2: blah has a set to 3 in the assignment mentioned in #2 above.
One'd infer that in C++ if you have a specialized argument-taking constructors declared, the default constructor is not created behind your back by the compiler anymore. I can't bother to look into the relevant place in the standard right now, editors feel free to correct this one.
It'd have helped you if you instrumented InnerClass as follows:
Keep a static instance counter, and copy it to every instance. That way you'd know which instance is reporting things back.
Manually write InnerClass & operator=(const InnerClass &) to see when is it invoked.

Answer 5

(PS: Are you coming from Java World to C++ by any chance?)
Output explained:
inner class constructed, a = 1 //this is unexpected
InnerClass is constructed with default constructor first
outer class constructing started, blah.a = 1 //this should be random data
This is the value of InnerClass constructed in previous step with default ctor
inner class constructed, a = 3
A temporary InnerClass is constructed with the overloaded ctor and assigned to the blah member (the implicit operator= is called - you can check by overloading the operator=)
inner class destructed, a = 3 //this is unexpected
The temporary InerClass created in the previous step is destroyed
outer class constructed
doSth: 3
done
outer class destructed
inner class destructed, a = 3
Answers:
Why is the default constructor of InnerClass called at the start of
OuterClass constructor?
Because you have InnerClass member. You should make it a pointer or use initializer list.
OuterClass::OuterClass()
: blah(3)
{
// automatically: blah = InnerClass();
std::cout << "outer class constructing started, blah.a = " << blah.a << std::endl;
// blah = InnerClass(3);
std::cout << "outer class constructed" << std::endl;
}
What and why is destructed in OuterClass
constructor ("inner class destructed, a = 3 //this is unexpected")?
The temporary InnerClass is destroyed here.
It seems that InnerClass object with a = 3 was destructed in the
OuterClass constructor, than why does method doSth() return 3
instead of random data?
The blah member now has a copy of InnerClass object with value 3
Why does removing an InnerClass()
constructor (from both InnerClass.hpp and InnerClass.cpp files)
result in compile-time error at the OuterClass constructor in
OuterClass.cpp file? The error says that no InnerClass() definition
found.
You mean removing the default constructor. Yes, the error is expected because blah member is first created with default ctor.