Does calling a constructor from a constructor create two objects? Yes.
Extra information that may help:
The base constructor is always called before derived constructor and destructors are called in the opposite order (derived first).
Code:
class A {};
class B : public A {};
class C : public B {};
When you create an instance of C, constructor of A is called followed by B and then C. When the instance is destroyed, the destructor of C is called followed by B and finally A. This order is important. Anything you do inside constructors does not effect the overall order. (Of course if you create an instance of A inside constructor of B then it may seem like the compiler isn't respecting this order but technically it's still the same order.)
As Salem has said, a good approach to understanding this is to add print statements to constructors and destructors. Two individual objects are guaranteed to have different memory address so you can print addresses as well to help you.
Sometimes your class has multiple constructors and you want to call two or more of them. Before C++11 there wasn't a nice way of doing this, you had to move code from constructors to methods and call them instead. As King Mir has mentioned C++11 lets you delegate constructors.
Code:
class A {
public:
A() {
std::cout << "A()\n";
}
};
class B : public A {
public:
B() : B(10) {
std::cout << "B()\n";
// B(10); // this will mostly likely do something you're not expecting, a temporary instance of B will be created, value of x is indeterminate
}
B(int i) : x(i) {
std::cout << "B(int)\n";
std::cout << "x is " << x << "\n";
}
private:
int x;
};
The output when you create B instance:
Code:
A()
B(int)
x is 10
B()
So the constructor of the base class is always called first which is good.