Casting enum to int in a template parameter

Question

I have defined a custom enum for convenience over a particular class, and it is now getting in the way for getting it processed by more general processes.

How should I perform this typecast?

// A templated value holder:
template <typename T>
struct Holder {
    T _value;
};

// A more general process..
template <typename T>
struct General {
    Holder<T> *holder;
};
// ..over integral types:
struct IntGeneral : General<int> {};
// Here is something interesting: I can tell that this process will work on
// any enum type. But I've found no way to make this explicit.

// Convenience for a particular case
typedef enum {One, Two, Three} Enum;
typedef Holder<Enum> Particular;


int main() { 

    Particular* a( new Particular { One } );
    IntGeneral ig { static_cast<Holder<int>*>(a) }; // compiler grumbles

    return EXIT_SUCCESS;
}

This is what I get:

error: invalid static_cast from type ‘Particular* {aka Holder<Enum>*}’ to type ‘Holder<int>*’

Is there a way I can keep the convenient Enum and get this code compiled?

---

EDIT: This turned out to be an XY problem. An answer to Y has been accepted here, and several discussed. X has been moved to another question.

Answer 1

You could add a templated conversion function that would allow Holder<T> to be converted to Holder<U> if T is convertible to U and T is an enum:

template <typename T>
struct Holder {
    T _value;

    template <typename U,
              typename = std::enable_if_t<
                std::is_convertible<T, U>::value && 
                std::is_enum<T>::value 
              >>
    operator Holder<U>() const {
        return {_value};
    }
};

Potentially just the convertibility check is sufficient, depending on your use-case.

This will let you write:

Holder<int> i = Holder<Enum>{One};

But it wouldn't let you do the pointer conversion as a cast. You'd have to allocate a whole new Holder<int>* to store the Holder<Enum>*.

Answer 2

Is it sufficient to replace:

IntGeneral ig { static_cast<Holder<int>*>(a) }; // compiler grumbles

With:

IntGeneral ig { new Holder<int>{a->_value} };

Since it is a struct, you can access the value. Personally I would use getters and setter, but as presented, that should do what you want.

Alternately

You could replace:

typedef Holder<Enum> Particular;

With:

typedef Holder<int> Particular;

Since the int can hold the Enum

Answer 3

I think the simplest way to get this to work is to specialize Holder<Enum> so that it has an implicit conversion to Holder<Int>.

template<>
struct Holder<Enum> {
  Enum _value;
  operator Holder<Int>() const { return { _value }; }
};

This is going to make copies of the enum though, so this might not do exactly what you want depending on what goes in the General processes.

Answer 4

The problem is that static_cast is not meant for casting pointers of different types. I suggest you to use reinterpret_cast, it should do the work. Also, you cannot instantiate object of type IntGeneral with a pointer.

Answer 5

There are some several changes you can make:

1. Add a parent type to the 'Holder' that can reference both generic and Particular types.
2. Define a constructor to the Holder that receives T
3. Define a constructor to the General that receives Holder address type

4. And for the initialization list of IntGeneral (this is a weird name because it's not general but I get the point) Initiate with a "Holder*" address.

   struct HolderBase {};
   
   template <typename T>
   struct Holder : HolderBase{
        Holder(T value){ _value = value; }
        T _value;
   };
   
   template <typename T>
   struct General {
       General(Holder<T>* h){ holder = h; }
       Holder<T>* holder;
   };
   
   struct IntGeneral : General<int> {
       IntGeneral(Holder<int>* holder) : General<int>(holder){}
   };
   
   typedef enum { One, Two, Three } Enum;
   typedef Holder<Enum> Particular;
   
   
   int main() {
   
      HolderBase* a(new Particular{ One });
      IntGeneral ig{ static_cast<Holder<int>*>(a) };
   
      return 0;
   }
   

hope this is what you were looking for