基于模板类型的枚举值

Question

tl;dr：有没有办法从 typename 派生枚举值？

详情： 我正在尝试模板化一个函数以在每个结构数据之前发送一个标题。标头存储在枚举类中，例如：

enum class TypeHeader {
  Test1 = 4;
  Test2 = 16;
  Test3 = 50;
};

我有许多带有字段和类型的结构。 示例结构：

struct Test1 {
  uint32_t field1;
  uint32_t field2;
}

struct Test2 {
  uint8_t field1;
  uint8_t field2;
}

struct Test3 {
  uint8_t field1;
  uint16_t field2;
}

结构的名称与枚举字段相同（不一定，我认为这可能会使事情变得更容易）

向服务器发送数据的函数：

template<typename T>
void send(const uint8_t* const s) {
  uint8_t data[2 + sizeof(T)];

  // data[1] = TypeHeader::???? << 8
  // data[0] = TypeHeader::????
  // i want data[0] and data[1] to have the struct id
  // as a uint16 which is in the enum TypeHeader

  memcpy(data + 2, s, sizeof(T));

  // then data is ready and I can send it...
}

我知道我可以向模板或函数添加额外的参数并传递 TypeHeader 值，但我想知道编译器是否有办法将类型名链接到 enum 标记，所以我可以这样做：

Test1 test1; 
send(test1);

Answer 1

您应该将值作为静态元素添加到您的结构定义中，如下所示：

enum class TypeHeader: uint16_t { // make it really a 16bit as you later access it as such!
  Test1 = 4,
  Test2 = 16,
  Test3 = 50,
};



struct Test1 {
  uint32_t field1;
  uint32_t field2;
  static constexpr TypeHeader header = TypeHeader::Test1; // not part of object but of the type!
};

struct Test2 {
  uint8_t field1;
  uint8_t field2;
  static constexpr TypeHeader header = TypeHeader::Test2;
};

struct Test3 {
  uint8_t field1;
  uint16_t field2;
  static constexpr TypeHeader header = TypeHeader::Test3;
};


template<typename T>
void send(const T& obj)
{
  uint8_t data[2 + sizeof(T)];

   // converting to the given type, even if T changes    
   data[1] = (std::underlying_type_t<decltype(obj.header)>)T::header >> 8; // you wrongly used <<!
   data[0] = (std::underlying_type_t<decltype(obj.header)>)T::header & 0xff;

  memcpy(data + 2, &obj, sizeof(T));
}


int main()
{
    Test1 t1{ 1,2 };
    send( t1 );
}

编辑：添加演员的描述：

obj.header 是一个枚举，我们不能直接将其用作数值。但是您想将其作为 2 字节缓冲区写入您的发送缓冲区，并具有 8 位低值和高值。因此，我们必须将其转换为整数值。枚举值定义为uint16_t 值。好的，但我们不想复制该定义，因为也许我们想稍后更改定义。因此，准确地使用我们使用的变量的类型是一个很好的 ida。或者，如果我们想更通用地使用我们的发送函数，我们也可以使用不同的枚举值，这些值都可以转换为我们的缓冲区数字表示。也许我们在 send 函数中有更多的东西来使它能够使用 32 位值或任何你想要的值。我添加了这个演员的想法，给你一个例子，如何准备你的模板化函数更通用。是的，你也可以直接投到uint16_t。但是，如果您使用已经从编译器获得的知识，那么让您的程序更易于维护总是一个好主意。如果你写了两次（在枚举定义中写一次，在转换时又写一次）你的类型你有很好的机会在以后忘记一次，如果你改变你的定义。

我们开始吧：

• obj.header 是变量，即使是 const
• decltype(obj.header) 为我们提供了枚举类型
• std::underlying_type_t 现在为我们提供了代表我们枚举的整数类型。我们已将其定义为 uint16_t！而我们用来投射的这种类型。

下一个补充：OP要求以下代码，用我的想法评论：

template <typename T> void send(const T& obj)
{ 
    auto header = (std::underlying_type_t<decltype(obj.header)>)T::header;

    // if your header now vary in the size, you must add an additional header
    // size information! If not, the receiver did not know if data is from 
    // header or from the following data field
    uint8_t data[sizeof(header) + sizeof(T)];

    // now you have the order of bytes in the header
    // in the same order as the machine uses ( endianess )
    // That is ok as long you use the same system architecture
    // to read back the data but it is not portable
    memcpy(data, &header, sizeof(T));

    // here you definitely write the data in the architecture dependent
    // order and also with potential padding bytes... 
    // As long as you know what you do, everything is fine.
    // But if you change from 32 bit to 64 bit or use pragma(pack)
    // you will change your serialized format!
    memcpy(data + sizeof(header), &obj, sizeof(T));
}

Answer 2

您不能使用类型（来自模板）作为枚举名称。

还有其他选择，例如模板变量：

template <typename T> static const uint16_t TypeHeader;

template <> const uint16_t TypeHeader<Type1> = 4;
template <> const uint16_t TypeHeader<Type2> = 16;
template <> const uint16_t TypeHeader<Type3> = 50;

然后，像这样使用它：

template<typename T>
void send(const uint8_t* const s) {
    uint8_t data[2 + sizeof(T)];

    data[0] = TypeHeader<T> & 0xFF;
    data[1] = (TypeHeader<T> >> 8) & 0xFF;

    memcpy(data + 2, s, sizeof (T));

    // then data is ready and I can send it...
}