Is it possible to put several objects together inside a union?

Question

What if I have this:

union{
    vector<int> intVec ;
    vector<float> floatVec ;
    vector<double> doubleVec ;
} ;

Of course, I'll be using just one of the 3 vectors. But... what happens when all the 3 vectors are contructed??
Would the consructors of the 3 vectors interfere with each other?? (since the 3 of them are in the same memory address)

Thanks.

Brendonbrenk

Answer 1

Current C++ standard does not allow non-POD types inside unions. You will get this compiler error from gcc:

error: member ‘std::vector<int, std::allocator<int> >
<anonymous union>::i’ with constructor not allowed in union
error: member ‘std::vector<int, std::allocator<int> >
<anonymous union>::i’ with destructor not allowed in union

New C++ standard (C++0x) proposes unrestricted unions, but it adds yet more object lifetime pitfalls to C++.

Ciccia

Answer 2

You cannot have unions containing non-POD class types. Your sample will not compile.

You can use boost::variant as a safe alternative to C unions. See the documentation on boost.org. You might, however, reconsider your design and use polymorphism instead. Depends on what you're trying to accomplish, of course.

Sarsaparilla

Yes, I know Boost::variant and Boost:any. I just wanted to be sure if this would be possible or not before considering a different approach. Thanks. – Brendonbrenk

You can have unions containing class types, but they must be POD. see Checkers' answer. – Alienable

Answer 3

From the C++ Standard, section 9.5:

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,

Here, for "non-trivial" read "useful" :-)

Hilda

Even more than that, trivial implies implicitly defined. If the constructor is defined in code, it is inherently non-trivial. – Nodab

Answer 4

Would the consructors of the 3 vectors interfere with each other?? (since the 3 of them are in the same memory address)

The C++ standard doesn't allow your program, so it's (at best!) implementation-defined what happens.

If, say, your implementation invokes all three default contructors, and those all alocate memory, and stores the pointer to the newly allocated space, the you have a memory leak (the first Two allocations are overwritten by the third).

If the destructors are all invoked and they all free "their" memory, you will be doing a double free (triple, acually); this is likely to corrupt the allocation data structure, which is a Bad Thing. Be happy if you crash, because it's much harder to debug if you don't.

I think these problems might be why the standard doesn't allow this.

(A more sensical thing might be to only default-construct the first class, but that's still not sensical, just less insane...)

Melodrama

Answer 5

Now C++ standard supports variant. Check https://en.cppreference.com/w/cpp/utility/variant.

std::variant

Defined in header

template <class... Types>   
class variant;

^{(since C++17)}

The class template std::variant represents a type-safe union. An instance of std::variant at any given time either holds a value of one of its alternative types, or in the case of error - no value (this state is hard to achieve, see valueless_by_exception).

As with unions, if a variant holds a value of some object type T, the object representation of T is allocated directly within the object representation of the variant itself. Variant is not allowed to allocate additional (dynamic) memory.

A variant is not permitted to hold references, arrays, or the type void. Empty variants are also ill-formed (std::variant<std::monostate> can be used instead).

A variant is permitted to hold the same type more than once, and to hold differently cv-qualified versions of the same type.

Consistent with the behavior of unions during aggregate initialization, a default-constructed variant holds a value of its first alternative, unless that alternative is not default-constructible (in which case the variant is not default-constructible either). The helper class std::monostate can be used to make such variants default-constructible.

Reconnoiter

Answer 6

You might want to have a look at Boost.Variant which can contain a single value of varying types.

Nodab