Is a Union Member’s Destructor Called

by

In your example that you provided str will not be destructed. The standard states in [class.union]/2

A union can have member functions (including constructors and destructors), but not virtual (10.3) functions. A union shall not have base classes. A union shall not be used as a base class. If a union contains a non-static data member of reference type the program is ill-formed. At most one non-static data member of a union may have a brace-or-equal-initializer . [ Note: If any non-static data member of a union has a non-trivial default constructor (12.1), copy constructor (12.8), move constructor (12.8), copy assignment operator (12.8), move assignment operator (12.8), or destructor (12.4), the corresponding member function of the union must be user-provided or it will be implicitly deleted (8.4.3) for the union. — end note ]

emphasis mine

So since both str and vec have special member functions that are not trivial you will need to provide them for the union yourself.

Do note that as per bogdan’s comments below the empty destructor is not enough. In [class.union]/8 we have

[…]If X is a union its variant members are the non-static data members;[…]

So all members of this union are variants. Then if we look at [class.dtor]/8 we have

After executing the body of the destructor and destroying any automatic objects allocated within the body, a destructor for class X calls the destructors for X’s direct non-variant non-static data members[…]

So the destructor will not automatically destroy the members of the union as they are variants.

You could make a tagged union like kennytm does here

struct TU {
   int type;
   union {
     int i;
     float f;
     std::string s;
   } u;

   TU(const TU& tu) : type(tu.type) {
     switch (tu.type) {
       case TU_STRING: new(&u.s)(tu.u.s); break;
       case TU_INT:    u.i = tu.u.i;      break;
       case TU_FLOAT:  u.f = tu.u.f;      break;
     }
   }
   ~TU() {
     if (tu.type == TU_STRING)
       u.s.~string();
   }
   ...
};

Which ensures the correct member is destroyed or just use a std::variant or boost::variant

More Related Contents:

  1. What are Aggregates and PODs and how/why are they special?
  2. Why is C++11’s POD “standard layout” definition the way it is?
  3. C++ local variable destruction order
  4. C++11 anonymous union with non-trivial members
  5. Why does destructor disable generation of implicit move methods?
  6. Questions regarding C++ non-POD unions
  7. memcpy/memmove to a union member, does this set the ‘active’ member?
  8. What exactly is nullptr?
  9. Why don’t compilers merge redundant std::atomic writes?
  10. How to change mode from c++98 mode in Dev-C++ to a mode that supports C++0x (range based for)?
  11. Copy constructor for a class with unique_ptr
  12. How to call a function on all variadic template args?
  13. std::array vs array performance
  14. lifetime of a std::initializer_list return value
  15. Brace-enclosed initializer list constructor
  16. Where can I use alignas() in C++11?
  17. Is it possible to determine if a type is a scoped enumeration type?
  18. Is it legal to declare a constexpr initializer_list object?
  19. C++11 way to index tuple at runtime without using switch
  20. How can I expand call to variadic template base classes?
  21. How do I erase elements from STL containers?
  22. What lasts after using std::move c++11
  23. error::make_unique is not a member of ‘std’
  24. Why can’t I replace std::map with std::unordered_map
  25. Can I legally reinterpret_cast between layout-compatible standard-layout types?
  26. C++11 std::threads vs posix threads
  27. Multiple “could not be resolved” problems using Eclipse with minGW
  28. Is substitution performed on a variadic parameter pack type if the pack is empty?
  29. Explicit Return Type of Lambda
  30. Why is this C++ wrapper class not being inlined away?

Leave a Comment