Deleted default constructor. Objects can still be created… sometimes

by

When viewing things this way it is easy to say there is complete and utter chaos in the way an object is initialized.

The big difference comes from the type of foo: if it is an aggregate type or not.

It is an aggregate if it has:

  • no user-provided constructors (a deleted or defaulted function does not count as user-provided),
  • no private or protected non-static data members,
  • no brace-or-equal-initializers for non-static data members (since c++11 until (reverted in) c++14)
  • no base classes,
  • no virtual member functions.

So:

  • in scenarios A B D E: foo is an aggregate
  • in scenarios C: foo is not an aggregate
  • scenario F:
    • in c++11 it is not an aggregate.
    • in c++14 it is an aggregate.
    • g++ hasn’t implemented this and still treats it as a non-aggregate even in C++14.
      • 4.9 doesn’t implement this.
      • 5.2.0 does
      • 5.2.1 ubuntu doesn’t (maybe a regression)

The effects of list initialization of an object of type T are:

  • …
  • If T is an aggregate type, aggregate initialization is performed. This takes care of scenarios A B D E (and F in C++14)
  • Otherwise the constructors of T are considered in two phases:
    • All constructors that take std::initializer_list …
    • otherwise […] all constructors of T participate in overload resolution […] This takes care of C (and F in C++11)
  • …

:

Aggregate initialization of an object of type T (scenarios A B D E (F c++14)):

  • Each non-static class member, in order appearance in the class definition, is copy-initialized from the corresponding clause of the
    initializer list. (array reference omitted)

TL;DR

All these rules can still seem very complicated and headache inducing. I personally over-simplify this for myself (if I thereby shoot myself in the foot then so be it: I guess I will spend 2 days in the hospital rather than having a couple of dozen days of headaches):

  • for an aggregate each data member is initialized from the elements of the list initializer
  • else call constructor

Doesn’t this beat the whole purpose of a deleted constructor?

Well, I don’t know about that, but the solution is to make foo not an aggregate. The most general form that adds no overhead and doesn’t change the used syntax of the object is to make it inherit from an empty struct:

struct dummy_t {};

struct foo : dummy_t {
  foo() = delete;
};

foo f{}; // ERROR call to deleted constructor

In some situations (no non-static members at all, I guess), an alternate would be to delete the destructor (this will make the object not instantiable in any context):

struct foo {
  ~foo() = delete;
};

foo f{}; // ERROR use of deleted function `foo::~foo()`

This answer uses information gathered from:

Many thanks to @M.M who helped correct and improve this post.

More Related Contents:

  1. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  2. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  3. C++11 aggregate initialization for classes with non-static member initializers
  4. When is a private constructor not a private constructor?
  5. static_assert dependent on non-type template parameter (different behavior on gcc and clang)
  6. Is a pointer with the right address and type still always a valid pointer since C++17?
  7. Understanding the example on lvalue-to-rvalue conversion
  8. Why does the standard differentiate between direct-list-initialization and copy-list-initialization?
  9. Self-initialization of a static constexpr variable, is it well-formed?
  10. Are notes and examples in the core language specification of the C++ Standard non-normative?
  11. Can I Reference Previous Members of an Initializer List?
  12. Why was the space character not chosen for C++14 digit separators?
  13. Why isn’t `std::initializer_list` defined as a literal type?
  14. Classes with both template and non-template conversion operators in the condition of switch statement
  15. Why is `make_unique` disallowed?
  16. Injected class name compiler discrepancy
  17. What changes to C++ made copy initialization work for class with explicit constructor?
  18. Directly write into char* buffer of std::string
  19. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  20. Take the address of a one-past-the-end array element via subscript: legal by the C++ Standard or not?
  21. Why class data members can’t be initialized by direct initialization syntax?
  22. Efficient unsigned-to-signed cast avoiding implementation-defined behavior
  23. Does not evaluating the expression to which sizeof is applied make it legal to dereference a null or invalid pointer inside sizeof in C++?
  24. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  25. When instantiating a template, should members of its incomplete argument types be visible?
  26. Which headers in the C++ standard library are guaranteed to include another header?
  27. How can an incomplete type be used as a template parameter to vector here?
  28. Erasing vector::end from vector
  29. C++ operator % guarantees
  30. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?

Leave a Comment