12

From what cppref says about value initialization

if T is a class type with no default constructor or with a user-provided or deleted default constructor, the object is default-initialized;

But since that class type has deleted default constructor, how could the object be default-initialized?

As far as I know, default initialization of class type needs the access of default constructor. If we have:

struct A { A() = delete; int k; };

Then A *a = new A; will fail, so does A* a = new A();.

But A a{}; is OK. But why? According to cppreference

Otherwise, If the braced-init-list is empty and T is a class type with a default constructor, value-initialization is performed.

Improve this question
14
  • Working example: godbolt.org/g/f8CWAF Commented May 17, 2018 at 14:22
  • @RichardCritten : That's on the right path, but that's not value-initialization, it's list-initialization. :-] Commented May 17, 2018 at 14:24
  • @RichardCritten See my newly edited post.This still requires a accessible default constructor. So I do not know why A a{} could work here. Commented May 17, 2018 at 14:33
  • @ildjarn, you're right, sorry about that; change foo f{10}; to foo f{};. Commented May 17, 2018 at 14:35
  • Related to value-initialization-of-class-object-without-default-constructor. Commented May 17, 2018 at 14:38

2 Answers 2

Reset to default
11

I think the standard just means "if T is a class type with deleted default constructor then goto default initialization". It would fail at last because the constructor selected for default initialization is deleted. It's used to distinguish with the 2nd case, i.e. "if T is a class type with a default constructor that is neither user-provided nor deleted", for that case zero-initialization is performed firstly, then default-initialization if T has a non-trivial default constructor.

A a{} is OK,but why?

Because when A is an aggregate type aggregate initialization is performed. Note that explicitly deleted constructors are allowed for aggregate type since C++11.

In all cases, if the empty pair of braces {} is used and T is an aggregate type, aggregate-initialization is performed instead of value-initialization.

And

An aggregate is one of the following types:

  • ...
  • class type (typically, struct or union), that has
    • ...
    • no user-provided, inherited, or explicit constructors (explicitly defaulted or deleted constructors are allowed) (since C++17) (until C++20)
    • ...

EDIT

Since C++20 the behavior changed; A a{}; would fail.

An aggregate is one of the following types:

  • ...
  • class type (typically, struct or union), that has
    • ...
    • no user-declared or inherited constructors (since C++20)
    • ...

A is not an aggregate again. A a{}; performs value-initialization (default-initialization), the deleted constructor is used and fails.

Improve this answer
Sign up to request clarification or add additional context in comments.

12 Comments

Is A a{} well-formed here?
@bigxiao Yes if A is an aggregate type.
The cppref says "If the number of initializer clauses is less than the number of members and bases (since C++17) or initializer list is completely empty , the remaining members and bases (since C++17) are initialized by their default initializers " . But since A has no default cotr, I think the initialization A a{} should fail consequently.
The sentence above is directly quoted in the page of aggregate initialization
@bigxiao It says "the remaining members...", i.e. initializing A's member, not A itself.
|
8

But since that class type has deleted default constructor, how could the object be default-initialized?

Stating that the object is default-initialized doesn't in of itself imply that default-initialization is a valid thing to do. The wording just forwards us into that process, it makes the initialization process coherent, it doesn't imply that it must succeed.

For instance:

struct A { A() = delete; A(int); // not an aggregate }; auto a = A();

The initializer is (), so this the object is value-initialized. In this case, that means it's default-initialized, which means we find a constructor.

Calling that constructor happens to be ill-formed, because it's deleted, which makes the whole initialization ill-formed. But we get to that point by way of default-initialization.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.