Why compiler doesn’t allow std::string inside union?

by

Because having a class with a non-trivial (copy/)constructor in a union doesn’t make sense. Suppose we have

union U {
  string x;
  vector<int> y;
};

U u;  // <--

If U was a struct, u.x and u.y would be initialized to an empty string and empty vector respectively. But members of a union share the same address. So, if u.x is initialized, u.y will contain invalid data, and so is the reverse. If both of them are not initialized then they cannot be used. In any case, having these data in a union cannot be handled easily, so C++98 chooses to deny this: (§9.5/1):

An object of a class with a non-trivial constructor (12.1), a non-trivial copy constructor (12.8), a non-trivial destructor (12.4), or a non-trivial copy assignment operator (13.5.3, 12.8) cannot be a member of a union, nor can an array of such objects.

In C++0x this rule has been relaxed (§9.5/2):

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 ]

but it is still a not possible to create (correct) con/destructors for the union, e.g. how do you or the compiler write a copy constructor for the union above without extra information? To ensure which member of the union is active, you need a tagged union, and you need to handle the construction and destruction manually e.g.

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();
   }
   ...
};

But, as @DeadMG has mentioned, this is already implemented as boost::variant or boost::any.

More Related Contents:

  1. Why should I use a pointer rather than the object itself?
  2. Are std::vector elements guaranteed to be contiguous?
  3. How to add additional libraries to Visual Studio project?
  4. Variable initialization in C++
  5. How to use the Qt’s PIMPL idiom?
  6. Purpose of returning by const value? [duplicate]
  7. problem sorting using member function as comparator
  8. C++, What does the colon after a constructor mean? [duplicate]
  9. Atomicity on x86
  10. How can I declare a member vector of the same class?
  11. Recursive typedef function definition : std::function returning its own type
  12. Why cannot a non-member function be used for overloading the assignment operator?
  13. How to generate all permutations of an array in sorted order?
  14. Number of days between two dates C++
  15. Calling the base class constructor from the derived class constructor
  16. GIF animation in Qt
  17. Creating a counter that stays synchronized across MPI processes
  18. Rotate an image in C++ without using OpenCV functions
  19. Copy a streambuf’s contents to a string
  20. How to Read from a Text File, Character by Character in C++
  21. Member access into incomplete type error
  22. What does ## in a #define mean?
  23. Undefined reference error for static constexpr member
  24. xcode update to version 2395. ld compile problem occurs: computedAtomCount && “more atoms allocated than expected
  25. Convert bitmap to PNG in-memory in C++ (win32)
  26. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?
  27. Why isn’t memcpy guaranteed to be safe for non-POD types?
  28. How do I convert a value from host byte order to little endian?
  29. How to get current CPU and RAM usage in C++?
  30. int *array = new int[n]; what is this function actually doing?

Leave a Comment