The new syntax “= default” in C++11

by

A defaulted default constructor is specifically defined as being the same as a user-defined default constructor with no initialization list and an empty compound statement.

§12.1/6 [class.ctor] A default constructor that is defaulted and not defined as deleted is implicitly defined when it is odr-used to create an object of its class type or when it is explicitly defaulted after its first declaration. The implicitly-defined default constructor performs the set of initializations of the class that would be performed by a user-written default constructor for that class with no ctor-initializer (12.6.2) and an empty compound-statement. […]

However, while both constructors will behave the same, providing an empty implementation does affect some properties of the class. Giving a user-defined constructor, even though it does nothing, makes the type not an aggregate and also not trivial. If you want your class to be an aggregate or a trivial type (or by transitivity, a POD type), then you need to use = default.

§8.5.1/1 [dcl.init.aggr] An aggregate is an array or a class with no user-provided constructors, [and…]

§12.1/5 [class.ctor] A default constructor is trivial if it is not user-provided and […]

§9/6 [class] A trivial class is a class that has a trivial default constructor and […]

To demonstrate:

#include <type_traits>

struct X {
    X() = default;
};

struct Y {
    Y() { };
};

int main() {
    static_assert(std::is_trivial<X>::value, "X should be trivial");
    static_assert(std::is_pod<X>::value, "X should be POD");
    
    static_assert(!std::is_trivial<Y>::value, "Y should not be trivial");
    static_assert(!std::is_pod<Y>::value, "Y should not be POD");
}

Additionally, explicitly defaulting a constructor will make it constexpr if the implicit constructor would have been and will also give it the same exception specification that the implicit constructor would have had. In the case you’ve given, the implicit constructor would not have been constexpr (because it would leave a data member uninitialized) and it would also have an empty exception specification, so there is no difference. But yes, in the general case you could manually specify constexpr and the exception specification to match the implicit constructor.

Using = default does bring some uniformity, because it can also be used with copy/move constructors and destructors. An empty copy constructor, for example, will not do the same as a defaulted copy constructor (which will perform member-wise copy of its members). Using the = default (or = delete) syntax uniformly for each of these special member functions makes your code easier to read by explicitly stating your intent.

More Related Contents:

  1. C++ Runtime Terminates std::out_of_range [closed]
  2. How can you iterate over the elements of an std::tuple?
  3. Is it possible to print a variable’s type in standard C++?
  4. What does T&& (double ampersand) mean in C++11?
  5. What is std::move(), and when should it be used?
  6. Variadic template pack expansion
  7. How is Meyers’ implementation of a Singleton actually a Singleton
  8. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  9. Is it safe to link C++17, C++14, and C++11 objects
  10. Why can’t clang with libc++ in c++0x mode link this boost::program_options example?
  11. C++11 features in Visual Studio 2012
  12. What is the partial ordering procedure in template deduction
  13. C++11: I can go from multiple args to tuple, but can I go from tuple to multiple args? [duplicate]
  14. Why are lambda expressions not allowed in an unevaluated operands but allowed in the unevaluated portions of constant expressions?
  15. Can I safely use OpenMP with C++11?
  16. std::to_string – more than instance of overloaded function matches the argument list
  17. Compile time triggered range check for std::vector
  18. C++11 “overloaded lambda” with variadic template and variable capture
  19. How can I use Standard Library (STL) classes in my dll interface or ABI?
  20. May std::vector make use of small buffer optimization?
  21. Is a constexpr array necessarily odr-used when subscripted?
  22. Range-based for with brace-initializer over non-const values?
  23. Returning a void?
  24. Futures vs. Promises
  25. How to get the precision of high_resolution_clock?
  26. STL algorithms: Why no additional interface for containers (additional to iterator pairs)?
  27. c++11 Thread class how to use a class member function
  28. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?
  29. Proper way to receive a lambda as parameter by reference
  30. When to use functors over lambdas

Leave a Comment