动态对象的统一初始化

Question

#include <memory>

struct foo
{
    std::unique_ptr<int> p;
};

int main()
{
    foo bar { std::unique_ptr<int>(new int(42)) };
    // okay

    new foo { std::unique_ptr<int>(new int(42)) };
    // error: no matching function for call to
    // 'foo::foo(<brace-enclosed initializer list>)'
}

Does uniform initialization not work with dynamic objects, or is this a shortcoming of g++ 4.6.1?

---

It works with g++ 4.7.1, but both lines in main fail to compile if foo inherits from another class:

struct baz
{
    // no data members, just some member functions
};

struct foo : baz
{
    std::unique_ptr<int> p;
};

Again, shortcoming of my compiler? Or does uniform initialization not play well with inheritance?

Answer 1

It builds fine with g++-4.7. So presumably the latter. I'll have a look to see if I can find stronger evidence via the docs.

And in response to the inheritance addendum:

This simpler case also fails to compile:

struct baz
{
};

struct foo : baz
{
    int b;
};

int main()
{
    foo bar { 12 };
}

With:

testoo.cpp:14:18: error: no matching function for call to ‘foo::foo(<brace-enclosed initializer list>)’
testoo.cpp:14:18: note: candidates are:
testoo.cpp:7:8: note: foo::foo()
testoo.cpp:7:8: note:   candidate expects 0 arguments, 1 provided
testoo.cpp:7:8: note: constexpr foo::foo(const foo&)
testoo.cpp:7:8: note:   no known conversion for argument 1 from ‘int’ to ‘const foo&’
testoo.cpp:7:8: note: constexpr foo::foo(foo&&)
testoo.cpp:7:8: note:   no known conversion for argument 1 from ‘int’ to ‘foo&&’

According to my reading of the standard, you have been getting aggregate initialization in your first example:

An aggregate is an array or a class (Clause 9) with no user-provided constructors (12.1), no brace-or-equal- initializers for non-static data members (9.2), no private or protected non-static data members (Clause 11), no base classes (Clause 10), and no virtual functions (10.3).

When an aggregate is initialized by an initializer list, as specified in 8.5.4, the elements of the initializer list are taken as initializers for the members of the aggregate, in increasing subscript or member order.

Note that this explicitly forbids base classes. So to sum up - aggregate initialization is not allowed in the presence of base classes. And hence neither of the second examples will compile.

Answer 2

both lines in main fail to compile if foo inherits from another class

Ah, uniform initialization works differently for aggregates and non-aggregates:

List-initialization of an object or reference of type T is defined as follows:

• If T is an aggregate, aggregate initialization is performed
• [...]
• Otherwise, if T is a class type, constructors are considered

An aggregate is [..] a class [...] with no base classes [...] and no virtual functions.

So I still have to write custom constructors in my case, since I need the subtype polymorphism here.

Answer 3

I do not have the final version in hand at the moment, but draft N3242, § 8.5.4 List-initialization explicitly states that list-initialization can be used as the initializer in a new expression. It also provides the following example:

new std::vector<std::string>{"once", "upon", "a", "time"}; // 4 string elements