如何从std::array高效生成十六进制字符串？

针对你的需求，我来分享几种既高效又简洁的实现方式，覆盖你提到的两种输出格式，同时对比不同方案的性能和可读性：

一、极致性能方案：静态查表+预分配内存 #

如果追求最快的处理速度，手动操作字符结合查表法是最优选择——它避免了流操作的开销，也不会有多余的内存分配。核心思路是：

1. 提前定义静态十六进制字符表，全局只初始化一次；
2. 预计算字符串所需的空间，一次性分配，避免std::string多次扩容；
3. 直接通过位运算拆分字节的高低4位，查表生成对应字符。

连续十六进制格式（如00010203...） #

#include <array>
#include <string>

// 静态十六进制字符表，全局只初始化一次
constexpr char hex_chars[] = "0123456789ABCDEF";

std::string getHexString(const std::array<unsigned char, 10>& data) {
    std::string result;
    // 预分配足够空间：每个字节占2个字符
    result.reserve(data.size() * 2);
    for (unsigned char byte : data) {
        // 拆分高4位和低4位，直接查表
        result += hex_chars[byte >> 4];
        result += hex_chars[byte & 0xF];
    }
    return result;
}

带0x前缀和空格的格式（如0x00 0x01...） #

std::string getHexStringWithPrefix(const std::array<unsigned char, 10>& data) {
    if (data.empty()) return "";
    std::string result;
    // 预分配空间：每个元素是"0xXX "，最后一个无空格，总长度为 data.size()*4 -1
    result.reserve(data.size() * 4 - 1);
    for (size_t i = 0; i < data.size(); ++i) {
        unsigned char byte = data[i];
        result += "0x";
        result += hex_chars[byte >> 4];
        result += hex_chars[byte & 0xF];
        // 最后一个元素不添加空格
        if (i != data.size() - 1) {
            result += ' ';
        }
    }
    return result;
}

二、简洁可读方案：C++20 std::format #

如果你的项目使用C++20或更高版本，std::format能让代码更简洁易读，虽然性能略低于手动查表，但对于大多数场景完全足够：

连续格式 #

#include <format>
#include <array>
#include <string>

std::string getHexString(const std::array<unsigned char, 10>& data) {
    std::string result;
    for (auto byte : data) {
        // {:02X} 表示输出两位大写十六进制，不足补0
        result += std::format("{:02X}", byte);
    }
    return result;
}

带前缀格式 #

std::string getHexStringWithPrefix(const std::array<unsigned char, 10>& data) {
    std::string result;
    for (size_t i = 0; i < data.size(); ++i) {
        if (i != 0) result += ' ';
        result += std::format("0x{:02X}", data[i]);
    }
    return result;
}

三、避坑提醒：尽量避免std::stringstream #

很多人会想到用std::stringstream来拼接，但它的格式化和内存分配开销很大，在需要高效处理的场景下不推荐，尤其是循环中多次插入时，性能差距会很明显。

测试代码 #

#include <iostream>

int main() {
    std::array<unsigned char, 10> data = {0,1,2,3,4,5,6,7,8,9};
    std::string result1 = getHexString(data);
    std::cout << result1 << std::endl; // 输出：00010203040506070809
    std::string result2 = getHexStringWithPrefix(data);
    std::cout << result2 << std::endl; // 输出：0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09
    return 0;
}

总结 #

• 追求极致性能：选静态查表+预分配内存的手动实现，无多余开销；
• 追求代码简洁：选C++20的std::format，可读性拉满；
• 避坑：远离std::stringstream的低效实现。

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