Есть самопальная структура Variant (платформа — Linux):

struct Variant
{
public:
    enum VariantType
    {
        VARIANT_BOOL,
        VARIANT_DOUBLE,
        VARIANT_PTR,
        VARIANT_INTEGER,
        VARIANT_DECIMAL,
        VARIANT_LONG,

        NUM_OF_VARIANT_TYPES,
    };

private:
    VariantType _type;

    union
    {
        bool   _bool_val;
        double _dbl_val;
        void * _ptr_val;
        int    _int_val;
        long   _long_val;

    } _data;

public:
    explicit Variant( bool val ) : 
        _type( VARIANT_BOOL )
    {
        _data._bool_val = val;
    }

    explicit Variant( double val ) : 
        _type( VARIANT_DOUBLE )
    {
        _data._dbl_val = val;
    }

    explicit Variant( void * val ) : 
        _type( VARIANT_PTR )
    {
        _data._ptr_val = val;
    }

    explicit Variant( int val ) : 
        _type( VARIANT_INTEGER )
    {
        _data._int_val = val;
    }

    explicit Variant( long val ) : 
        _type( VARIANT_LONG )
    {
        _data._long_val = val;
    }
};

Вопрос в том, как реализовать арифметику для этого типа? Понятно, что, например, long c double, например, сравнивать можно, а long со строкой — нет смысла. Не писать же выбор допустимых типов перебором. Первое, что приходит в голову — создать квадратную матрицу с указателями на функции сравнения. Нормальное ли это решение, или я не туда копаю?