在模板参数中将枚举转换为 int

Question

为了方便特定类，我定义了一个自定义enum，现在它妨碍了更通用的进程对其进行处理。

我应该如何执行这种类型转换？

// 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;
}

这是我得到的：

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

有没有办法让我保持方便的Enum 并编译这段代码？

---

编辑：原来是XY problem。此处已接受 Y 的答案，并讨论了几个。 X 已移至another question。

Answer 1

替换就够了：

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

与：

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

因为它是一个结构体，所以你可以访问它的值。就我个人而言，我会使用 getter 和 setter，但如前所述，这应该可以满足您的需求。

交替

你可以替换：

typedef Holder<Enum> Particular;

与：

typedef Holder<int> Particular;

由于int 可以容纳Enum

Answer 2

如果T 可转换为U 并且T 是一个枚举，您可以添加一个模板化转换函数，该函数将允许Holder<T> 转换为Holder<U>：

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};
    }
};

可能只是可兑换性检查就足够了，具体取决于您的用例。

这会让你写：

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

但它不允许您将指针转换作为强制转换。您必须分配一个全新的Holder<int>* 来存储Holder<Enum>*。

Answer 3

我认为让它工作的最简单方法是专门化Holder<Enum>，以便它可以隐式转换为Holder<Int>。

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

不过，这将复制枚举，因此根据 General 进程中的内容，这可能无法完全按照您的意愿进行。

Answer 4

问题是static_cast 并不意味着转换不同类型的指针。我建议你使用reinterpret_cast，它应该可以工作。此外，您不能使用指针实例化 IntGeneral 类型的对象。

Answer 5

您可以进行一些更改：

1. 向“Holder”添加一个父类型，该类型可以引用泛型和特定类型。
2. 为接收T的Holder定义一个构造函数
3. 为接收Holder地址类型的General定义一个构造函数

4. 对于 IntGeneral 的初始化列表（这是一个奇怪的名称，因为它不是通用的，但我明白了）以“Holder*”地址启动。

   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;
   }
   

希望这就是你要找的东西