如何在C++中安全地将char数组转换为指定类型？

问题描述 #

通过RS485线路接收的数据存储在vector<char>中，需要将其转换为bool、int等基础类型。当前实现使用reinterpret_cast直接强制转换，存在内存安全问题且未处理字节序，需要安全的C++实现方式。

当前不安全的实现代码：

template<typename To>
static std::size_t parseBinaryToType(const char* input, To& destination) {
    destination = *(reinterpret_cast<const To*>(input)); //FIXME 
    return sizeof(destination);
}
//EXAMPLE
enum class SomeEnum: uint16_t {
  BAR,
  BAZ
};

class Foo {
  SomeEnum m_Enum;
  uint8_t m_Int;
  bool m_Bool;
public: 
  static Foo deserializeFrom(const char* const buffer) {
    Foo result;
    std::size_t offset = 0;
    offset+= parseBinaryToType(buffer + offset, result.m_Enum);
    offset+= parseBinaryToType(buffer + offset, result.m_Int);
    offset+= parseBinaryToType(buffer + offset, result.m_Bool);
    return result;
  }
};

安全实现方案 #

1. 核心思路 #

摒弃直接内存地址强制转换，通过逐字节读取构建目标值的方式避免内存对齐、类型安全问题；同时显式处理字节序，匹配RS485传输协议约定的大端/小端规则。

2. 完整实现代码 #

#include <cstdint>
#include <algorithm>
#include <type_traits>

// 手动判断本地字节序（兼容C++20以下版本）
inline bool isLittleEndian() {
    const uint16_t test = 0x0102;
    return *reinterpret_cast<const uint8_t*>(&test) == 0x02;
}

template<typename To>
requires std::is_arithmetic_v<To> || std::is_enum_v<To>
static std::size_t parseBinaryToType(const char* input, To& destination, bool isBigEndian = true) {
    using UnderlyingType = std::conditional_t<std::is_enum_v<To>, std::underlying_type_t<To>, To>;
    UnderlyingType value = 0;
    const std::size_t size = sizeof(UnderlyingType);

    // 按传输字节序组合值
    if (isBigEndian) {
        // 大端：高位字节在前
        for (std::size_t i = 0; i < size; ++i) {
            value = (value << 8) | static_cast<uint8_t>(input[i]);
        }
    } else {
        // 小端：低位字节在前
        for (std::size_t i = 0; i < size; ++i) {
            value |= static_cast<uint8_t>(input[i]) << (8 * i);
        }
    }

    // 转换为本地字节序（若传输字节序与本地不同）
    if ((isBigEndian && isLittleEndian()) || (!isBigEndian && !isLittleEndian())) {
        std::uint8_t* bytes = reinterpret_cast<std::uint8_t*>(&value);
        std::reverse(bytes, bytes + size);
    }

    destination = static_cast<To>(value);
    return size;
}

// bool类型特殊处理（避免多字节误判）
template<>
std::size_t parseBinaryToType<bool>(const char* input, bool& destination, bool) {
    // 协议约定：非0字节为true，0为false（可根据实际调整）
    destination = static_cast<uint8_t>(input[0]) != 0;
    return 1;
}

// 示例使用
enum class SomeEnum: uint16_t {
  BAR,
  BAZ
};

class Foo {
  SomeEnum m_Enum;
  uint8_t m_Int;
  bool m_Bool;
public: 
  static Foo deserializeFrom(const char* const buffer) {
    Foo result;
    std::size_t offset = 0;
    // 假设RS485传输采用大端字节序
    offset += parseBinaryToType(buffer + offset, result.m_Enum, true);
    offset += parseBinaryToType(buffer + offset, result.m_Int, true); // uint8_t字节序无影响
    offset += parseBinaryToType(buffer + offset, result.m_Bool);
    return result;
  }
};

关键特性说明 #

• 类型安全约束：通过requires限定仅支持算术类型和枚举类型，防止错误类型传入。
• 枚举兼容：自动获取枚举的底层数值类型，统一处理转换逻辑。
• 字节序适配：支持大端/小端传输协议，自动转换为本地字节序，无未定义行为。
• 内存安全：全程通过逐字节读取构建目标值，避免了reinterpret_cast带来的对齐问题和内存访问风险。
• bool专用逻辑：单独特化处理bool类型，符合二进制协议的常见约定，避免多字节数据误判。

内容的提问来源于stack exchange，提问作者Typhaon