Question

I have a certain problem and I was stuck at which approach is better than the other:

A structure with an enum that defines the data in union member OR
A group of classes with inheritance

Sample code is given below:

Union based Structure

  typedef union TokenValue{
   bool bValue;
   long lvalue;
   double dvalue;
   std::string svalue;
   }

  class Token{
  public:
   TokenType type;
   TokenValue value;
   };

Class Inheritance

class TokenBase{
public:
  TokenType type;
  };



class TokenNumber: public TokenBase{
public:
bool isInt;
long lvalue;
double dvalue;
};

class TokenString: public TokenBase{
 public:
  std::string svalue;
 };

Answer 1

This type of design is known as a discriminated union or tagged union. You can Google for “C++ discriminated union” to see several examples of and approaches to this type of design.

A C union is usually considered a bit low-level and unsafe for C++. As Pete Becker said, your union-based solution should provide accessors instead of directly exposing the unsafe union member. unions also have the disadvantage that, prior to C++11, they can’t contain non-POD data structures (so no std::string).

An inheritance-based solution has the advantage that you can start using polymorphism (e.g., add a virtual PrintTo method). (You can, of course, accomplish similar results by adding a PrintTo method to a union-based solution that does a switch over TokenType, but that’s non-OO.)

A union-based solution would probably be lighter-weight than an inheritance-based solution (no vtable). That might be preferable for something as low-level as lexer tokens.

If third-party libraries are permitted, I’d strongly recommend taking a look at Boost.Variant for a more C++ approach to discriminated unions.