Why does this class object declaration work? - c++

Question

Suppose I have a class
class Test{
public:
int x;
Test(const Test& obj){x=obj.x;}
};
Why does
Test object_name(Test random_name);
run and does not need another object as a parameter?.
.Something like Test random_name(Test another_random(...)), making it a never ending way of declaring the object?

Answer 1

This line:
Test object_name(Test random_name);
declares a function called object_name that takes a Test as a paramter and returns a Test. It does not declare an object. It is perfectly legal to declare a function like this inside another function, it's just implicitly extern.

Answer 2

Substitute Test with a PoD like int and you will see what is happening
Test object_name(Test random_name); //1
int object_name(int random_name); //2
You can see that the second statement is a function declaration which takes an int as argument and returns an int.
This is due to a well-known rule in CPP related to ambiguity resolution.
From the CPP working draft (N4713):
9.8 Ambiguity resolution [stmt.ambig]
1 There is an ambiguity in the grammar involving expression-statements and declarations: An expression-statement with a function-style explicit type conversion as its leftmost subexpression can be indistinguishable from a declaration where the first declarator starts with a (. In those cases the statement is a declaration.
2 [ Note: If the statement cannot syntactically be a declaration, there is no ambiguity, so this rule does not apply. The whole statement might need to be examined to determine whether this is the case.

Answer 3

Here's a refactored version that should help explain what's going on. I've added another constructor to illustrate what's going on.
#include <iostream>
using namespace std;
class Test{
public:
int x = 27;
Test(const int y) : x(y) { cout << "ctor-1" << endl; }
~Test() {}
Test(const Test& obj) : x(obj.x) { cout << "ctor-2" << endl; }
operator int() const { return x; }
};
int main()
{
cout << "Creating function declaration" << endl;
Test object_name(Test random_name);
// This works fine
cout << "Creating alpha" << endl;
Test alpha(4);
cout << "Calling `object_name`" << endl;
cout << object_name(alpha) << endl;
// This fails because object_name is a function.
// cout << object_name.x << endl;
return 0;
}
Test object_name(Test random_name)
{
cout << "Creating another Test within `object_name`." << endl;
return Test(random_name.x + 13);
}
Here, we see that the first constructor is invoked twice: once for alpha and again within object_name. The second constructor is invoked when we call object_name, which accepts a parameter passed by value.
Output
Creating function declaration
Creating alpha
ctor-1
Calling `object_name`
ctor-2
Creating another Test within `object_name`.
ctor-1
17