I am trying to get my head around the new C++11 non-trivial unions in Visual Studio 2015. Please have a look at a simplified class I created (note that this code might not compile in its current form):

class Type
{
public:
  Type() :
    mKind(eObject),
    mObject()
  {
  }

?  // move constructor and operator= removed

  Type(const Type& that) :
    mKind(eObject),
    mObject()
  {
    if ( that.mKind == eArray ) {
      mKind = eArray;
      mArray.mDimension = 1;
      mArray.mType.reset(new Type()); // <-- here I get crashes due to uninitialized mType
    }
    else {
      mObject.mName = that.eObject.mName;
    }
  }

  enum Kind { eArray, eObject } mKind;
  struct ArrayInfo {
    std::unique_ptr<Type> mType;
    int mDimension;
  };

  struct ObjectInfo {
    String mName;
  };

  union {
    ArrayInfo  mArray;
    ObjectInfo mObject;
  };
}

I read that you may only initialize one member of the union (otherwise the constructor is ill formed). In this case I choose the mObject variable. Compiling works fine and well, but at runtime when I try to assign values to the mArray part I get crashes as it seems that it has not been initialized. I have looked through numerous resources about non-trivial unions and they always only have a std::string in there. Now I wonder how I can make this work. Do I need something like:

mObject.~String();
new (&mArray) ArrayInfo(); 

Thanks for the help.

The Type class is used in my custom script language to specify the type of for example a variable, class, function argument, etc. To preserve memory I wanted to give this new C++11 functionality a try as that would prevent memory allocations of the structs in case a pointer is used.

class Type
{
public:
  Type() :
    mKind(eObject),
    mName()
  {

  Type(const Type& that) :
    mKind(eObject),
    mName()
  {

I read that you may only initialize one member of the union (otherwise the constructor is ill formed). In this case I choose the mObject variable.

You don't initialize any of the union members (see the initializer lists quoted above). You only perform assignment to the uninitialized members within the constructor body.

Right, I fixed that in my code. I think I got it working with the proposal I made myself. It works both with GCC and visual studio. E.g.:

Type(const Type& that) :
    mKind(eObject),
    mObject()
  {
    if ( that.mKind == eArray ) {
      mKind = eArray;
      new (&mArray.mType) std::unique_ptr<Type>(new Type()));
      mArray.mDimension = 1;
    }
    else {
      mObject.mName = that.eObject.mName;
    }
 }