c++ Constructor behavior - c++

Question

i'm newbie in c++ languge, and i'm fimiliar with java language.
in Java world, the code looks ok , but not in c++.
can someone please explain why the both constructors are called?
class Position {
public:
Position(void)
{
std::cout<<"defualt constructor\n";
}
Position(unsigned int row,unsigned int col)
{
std::cout<<"two Arguments constructor\n";
row_index = row;
col_index = col;
}
private:
unsigned int row_index;
unsigned int col_index;
};
class Tool
{
public:
Tool(char Team,unsigned int row,unsigned int col)
{
pos = Position(row,col);
team = Team;
}
std::string To_string()
{
std::string str = "team: ";
str+= team;
str+= " pos: ";
str+= pos.To_string();
return str;
}
char Get_team()
{
return team;
}
private:
Position pos;
char team; // A or B
};
int main(void)
{
Tool t = Tool('A',1,3);
return 0;
}
i intended to call for the two arguments constructor
OUTPUT:
defualt constructor
two Arguments constructor

Answer 1

In the Tool class the Position object is first default constructed before the execution of the Tool constructor body is executed. Then you create a new temporary Position object in the Tool constructor body, and use it to assign to pos.
The important part here is that object construction is a three-step process:
The object is allocated
The object is initialized and all its members are constructed (here the Position default constructor is called)
The constructor of the object is executed (here the two-argument Position constructor is called)
To only use the two-argument Position constructor, and not simply assign to the pos object, you need to use an constructor initializer list. You do this by modifying the Tool constructor as this:
Tool(char Team,unsigned int row,unsigned int col)
: pos(row, col), // Initializes the `pos` object
team(Team) // Initialize the `team` member
{
// No code needed, the members have already been initialized
}

Answer 2

In C++, all member variables are constructed before the body of the constructor is entered. Your code default automatically constructs a Position, and then in the body of the constructor creates another Position and assigns it to the previously constructed one.
You need to pass the parameters of Position using an initialisation list:
Tool(char Team,unsigned int row,unsigned int col) : pos( row, col ), team(Team) {
// constructor now empty
}
In general, the body of a constructor should be empty.

Answer 3

When the execution enters constructor body, member objects, of the owning class, need to be constructed (default constructor is used, if no explicit call to constructor is specified).
Upon entering the constructor body, Position(row,col) in pos = Position(row,col); creates a temporary Position object, which gets assigned to pos.
If you want to avoid calling default constructor, of member objects, in such a case, use initialize members in an initializer-list:
Tool(char Team,unsigned int row,unsigned int col)
: pos (row, col), team (Team)
{
}
Why the code, in Java, works, as you expect, is due to the fact, that you, always, operate on references to objects, rather than on objects, as values. And non-initialized member object references in Java, would be default initialized to null (if memory serves right), until you create an object, and assign a reference to it, to a member variable.