"Двойной" доступ к переменным класса

class EnumerousVariables
{
public:
    EnumerousVariables();
    ~EnumerousVariables();
 
    TypeA&  getA() const;
    TypeB&  getB() const;
    // ...
    TypeZZ& getZZ() const;
 
    UniformType& operator [] (int i) const;
 
private:
    Type A a;
    TypeB b;
    // ...
    TypeZZ zz;
};

class UniformType
{
public:
    UniformType()
    UniformType(const TypeA& _a);
    UniformType(const TypeB& _b);
    // ...
    UniformType(const TypeZZ& _zz);
 
    ~UniformType();
 
    TypeA&  toTypeA(bool& isOK) const;
    TypeB&  toTypeB(bool& isOK) const;
    // ...
    TypeZZ& toTypeZZ(bool& isOK) const;
};

EnumerousVariables foo = EnumerousVariables();
// где:
// foo[0] == UniformType(foo.getA())
// foo[1] == UniformType(foo.getB())
// и т.д.

return *(ptrArray[i]);

return UniformType(*(ptrArray[i]))

TypeA&  getA() const;

UniformType&  getA() const
{
   return UniformType(_a);
}

TypeA& getA() const;
// и т.д.

TypeA aa = foo.getA().toTypeA()

auto

TypeA&  toTypeA(bool& isOK) const;

#include <iostream>
 
typedef int TypeA;
typedef double TypeB;
 
 
class UniformType
{
public:
    UniformType()
        : _type(-1)
        , _ptr(0)
    {   }
 
    ~UniformType()
    {
        delete _ptr;
    }
 
    UniformType( UniformType & rhs)
        : _type(-1)
        , _ptr(0)
    {
        DeepCopy(rhs);
    }
 
    explicit UniformType(const TypeA& _a)
        : _type(0)
    {
        _ptr = new TypeA(_a);
    }
 
    explicit UniformType(const TypeB& _b)
        : _type(1)
    {
        _ptr = new TypeB(_b);
    }
 
    UniformType& operator =( UniformType rhs )
    {
        DeepCopy( rhs );
        return *this;
    }
 
    void DeepCopy( UniformType & rhs)
    {
        delete _ptr;
 
        _type = rhs._type;
 
        switch( _type )
        {
        case 0:
            _ptr = new TypeA(rhs.toTypeA()); break;
        case 1:
            _ptr = new TypeB(rhs.toTypeB()); break;
        }
    }
 
    TypeA & toTypeA()
    {
        if( _type != 0 ) throw int(0);
        return *reinterpret_cast<TypeA*>(_ptr);
    }
 
    TypeB & toTypeB()
    {
        if( _type != 1 ) throw double(1);
        return *reinterpret_cast<TypeB*>(_ptr);
    }
 
private:
    int _type;
 
    void * _ptr;
};
 
 
class EnumerousVariables
{
public:
    EnumerousVariables()
    {
        _u[0] = UniformType(10);
        _u[1] = UniformType(3.14);
    }
 
    TypeA&  getA()
    {
        return _u[0].toTypeA();
    }
    TypeB&  getB()
    {
        return _u[1].toTypeB();
    }
 
    UniformType& operator [] (int i)
    {
        return _u[i];
    }
 
private:
    UniformType _u[2];
};
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    EnumerousVariables ev;
 
    std::cout << ev[0].toTypeA() << "\n";
    std::cout << ev[1].toTypeB() << "\n";
//  std::cout << ev[1].toTypeA();
 
    return 0;
}

TypeA  toTypeA(bool& isOK) const;