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

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.

In C++98/03, members of a union can't have constructors, destructors, virtual member functions, or base classes.

So basically, you can only use built-in data types, or PODs

Note that it is changing in C++0x: Unrestricted unions

union {
    int z;
    double w;
    string s;  // Illegal in C++98, legal in C++0x.
};

From the C++ spec §9.5.1:

An object of a class with a non-trivial constructor, a non-trivial copy constructor, a non-trivial destructor, or a non-trivial copy assignment operator cannot be a member of a union.

The reason for this rule is that the compiler will never know which of the destructors/constructors call, since it never really knows which of the possible objects is inside the union.

The garbage is introduced if you

1. assign a string
2. then assign an int or float
3. then a string again

string manages memory somewhere else. This information is most likely some pointer. This pointer is garbaged when assigning the int. Assigning a new string should destroy the old string, which is not possible.

The second step should destroy the string, but does not know, if there has been a string.

They obviously have found a solution for this problem in the meantime.

You can now do it.
Of course if you initialize any other member of the union first, or simply don't initialize the string at all, then there's a problem.
Since the string class overloads the assignment operator, you can't then initialize the string with an assignment operation:

this->union_string = std::string("whatever");

Will fail because you're still using the assignment operator.

To properly initialize a union string after you've put something else in the union or not initialized it in the first place, you have to call the constructor directly on that memory:

new(&this->union_string) std::string("whatever");

This way you're simply not using the assignment function at all.

Another concern is your compiler should make you make a destructor, and if for some reason not, you should make it anyway. Since it's a union, by the end of your class's lifetime the compiler can't know whether that union memory is used by the string or something else, so your destructor should call the string's destructor if that's the case.
So if you don't do it, you'll have a memory leak since the constructor for the string is never called, and it never knows to release the memory it's using.

In new C++ standard (I tested it in C++17), you can use a complex type as a member of union.

    struct ustring
    {
        union
        {
            string s;
            wstring ws;
        };

        bool bAscii = true;
        ~ustring()
        {
            if (bAscii)
            {
                s.~string();
            }
            else
            {
                ws.~wstring();
            }
        }
    };

However, you should be very careful. Think about you construct s but destruct ws.