时间:2019-03-17 标签:c++: calling constructors via curly braces?

Question

class A 
{
    int value_;
    public:
    A(int value):value_(value){}
};

A get_a1(int value)
{
    return A(value);
}

A get_a2(int value)
{
    return {value};
}


int main()
{
    A a1 = get_a1(1);
    A a2 = get_a2(2);
}

get_a1() 和 get_a2() 之间有什么区别(如果有的话)？

如何调用return {value};？ (我猜“通过大括号调用构造函数”不是引用此内容的正确方法)

Answer 1

就您而言，根本没有区别。但如果你稍微修改一下代码，就会有明显的差异!

首先，您可以通过不同的方式构造类型，所有这些都在此处描述:initilization

如果您的类还提供了一个采用 std::initializer_list 的构造函数，那么差异就出现了。

请参阅修改/扩展的以下代码以显示差异:

class A 
{   
    public:
        A(int value):value_(value){ std::cout << "int" << std::endl;}
        A(const std::initializer_list<int>& ){ std::cout << "list" << std::endl;}
        void print()
        {   
            std::cout << value_ << std::endl;
        }   
    private:
        int value_;
};  

A get_a1(int value)
{   
    std::cout << "()" << std::endl;
    return A(value);
}   

A get_a2(int value)
{
    std::cout << "{}" << std::endl;
    return {value};
}


int main()
{   
    A a1 = get_a1(1);
    a1.print();
    A a2 = get_a2(2);
    a2.print();
}   

如果您运行该程序，您将看到使用 {} 将使用 std::initializer_list 并使用 () 调用构造函数将使用您的 int 构造函数。

标准中描述了为什么:

§13.3.1.7 [over.match.list]/p1:

When objects of non-aggregate class type T are list-initialized (8.5.4), overload resolution selects the constructor in two phases:

• Initially, the candidate functions are the initializer-list constructors (8.5.4) of the class T and the argument list consists of the initializer list as a single argument.
• If no viable initializer-list constructor is found, overload resolution is performed again, where the candidate functions are all the constructors of the class T and the argument list consists of the elements of the initializer list.

If the initializer list has no elements and T has a default constructor, the first phase is omitted. In copy-list-initialization, if an explicit constructor is chosen, the initialization is ill-formed.

此外，初始化列表构造函数不允许缩小范围!

§8.5.4 List-initialization

(3.4) Otherwise, if T is a class type, constructors are considered. The applicable constructors are enumerated and the best one is chosen through overload resolution ([over.match], [over.match.list]). If a narrowing conversion (see below) is required to convert any of the arguments, the program is ill-formed.