为什么这个类对象声明有效？

Question

假设我有一堂课

class Test{
  public:
    int x;
    Test(const Test& obj){x=obj.x;}
};

为什么

Test object_name(Test random_name);

运行并不需要另一个对象作为参数？ 。 Test random_name(Test another_random(...)) ，使它成为一种永无止境的声明对象的方式？

Answer 1

这一行：

Test object_name(Test random_name);

声明一个名为object_name的函数，它将Test作为参数并返回Test 。 它不声明对象。 在另一个函数中声明这样的函数是完全合法的，它只是隐式extern 。

Answer 2

使用像int这样的PoD代替Test ，你会看到发生了什么

Test object_name(Test random_name); //1

int object_name(int random_name); //2

您可以看到第二个语句是一个函数声明，它将int作为参数并返回一个int 。

这是由于CPP中与模糊度解析相关的众所周知的规则。
从CPP工作草案（N4713）：

9.8歧义解决[stmt.ambig]

1语法中涉及表达式语句和声明存在歧义： 具有函数式显式类型转换的表达式语句，因为其最左侧的子表达式与第一个声明符以a开头的声明无法区分（。 在这些情况下，声明是一个声明 。

2 [注意： 如果语句在语法上不能成为声明，则不存在歧义，因此该规则不适用 。 可能需要检查整个陈述以确定是否是这种情况。

Answer 3

这是一个重构版本，应该有助于解释发生了什么。 我添加了另一个构造函数来说明发生了什么。

#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);
}

在这里，我们看到第一个构造函数被调用两次：一次是alpha ，另一次是object_name 。 当我们调用object_name ，将调用第二个构造函数， object_name接受由value传递的参数。

产量

Creating function declaration
Creating alpha
ctor-1
Calling `object_name`
ctor-2
Creating another Test within `object_name`.
ctor-1
17