How is “=default” different from “{}” for default constructor and destructor?

by

This is a completely different question when asking about constructors than destructors.

If your destructor is virtual, then the difference is negligible, as Howard pointed out. However, if your destructor was non-virtual, it’s a completely different story. The same is true of constructors.

Using = default syntax for special member functions (default constructor, copy/move constructors/assignment, destructors etc) means something very different from simply doing {}. With the latter, the function becomes “user-provided”. And that changes everything.

This is a trivial class by C++11’s definition:

struct Trivial
{
  int foo;
};

If you attempt to default construct one, the compiler will generate a default constructor automatically. Same goes for copy/movement and destructing. Because the user did not provide any of these member functions, the C++11 specification considers this a “trivial” class. It therefore legal to do this, like memcpy their contents around to initialize them and so forth.

This:

struct NotTrivial
{
  int foo;

  NotTrivial() {}
};

As the name suggests, this is no longer trivial. It has a default constructor that is user-provided. It doesn’t matter if it’s empty; as far as the rules of C++11 are concerned, this cannot be a trivial type.

This:

struct Trivial2
{
  int foo;

  Trivial2() = default;
};

Again as the name suggests, this is a trivial type. Why? Because you told the compiler to automatically generate the default constructor. The constructor is therefore not “user-provided.” And therefore, the type counts as trivial, since it doesn’t have a user-provided default constructor.

The = default syntax is mainly there for doing things like copy constructors/assignment, when you add member functions that prevent the creation of such functions. But it also triggers special behavior from the compiler, so it’s useful in default constructors/destructors too.

More Related Contents:

  1. When is a private constructor not a private constructor?
  2. error: use of deleted function
  3. Specialized template function with deleted “general” case fails to compile with g++
  4. Initializing an std::array of non-default-constructible elements?
  5. What is a smart pointer and when should I use one?
  6. push_back vs emplace_back
  7. Check if a class has a member function of a given signature
  8. A positive lambda: ‘+[]{}’ – What sorcery is this? [duplicate]
  9. How do I expand a tuple into variadic template function’s arguments?
  10. Initializer lists and RHS of operators
  11. Do rvalue references to const have any use?
  12. How to succinctly, portably, and thoroughly seed the mt19937 PRNG?
  13. Is is_constexpr possible in C++11?
  14. Does constexpr imply inline?
  15. C++11 constexpr function pass parameter
  16. Do rvalue references allow dangling references?
  17. What does this variadic template code do?
  18. Get base class for a type in class hierarchy
  19. Why is my object not being copied when move constructor is deleted?
  20. On how to recognize Rvalue or Lvalue reference and if-it-has-a-name rule
  21. `auto` specifier type deduction for references
  22. What is std::promise?
  23. TMP: how to generalize a Cartesian Product of Vectors?
  24. Random output different between implementations
  25. How can I pass std::unique_ptr into a function
  26. What is the difference between an empty and a null std::shared_ptr in C++?
  27. Can lambda functions be recursive? [duplicate]
  28. Raw pointer lookup for sets of unique_ptrs
  29. Deprecated throw-list in C++11
  30. brace initialization for inherited pod

Leave a Comment