你的原始实现虽然能正常运行，但确实存在可以优化的空间——不管是代码的惯用性还是执行效率。下面分别给出对应的改进方案：

一、更符合C++惯用风格的实现方式 #

C++风格的核心是类型安全、代码简洁、避免C风格的手动内存/缓冲区管理。我们可以用标准库的字符串工具替代sprintf，同时利用模板让函数更安全通用：

#include <vector>
#include <string>
#include <iostream>

// 用模板数组引用，自动推导数组长度，避免硬编码越界风险
template <std::size_t N>
void add_chars(std::vector<char>& vec, const unsigned (&val)[N]) {
    // 范围for循环遍历数组，代码更简洁
    for (const auto num : val) {
        // 用std::to_string完成数字到字符串的转换，类型安全且无需手动管理缓冲区
        const std::string num_str = std::to_string(num);
        // 直接从string的迭代器插入vector，语义清晰
        vec.insert(vec.end(), num_str.begin(), num_str.end());
    }
}

int main() {
    std::vector<char> chars;
    // 补全数组的10个元素（原始代码少了一个）
    constexpr unsigned val[10] = {1, 200, 3, 4, 5, 6000, 7, 8, 9000, 0};
    add_chars(chars, val);
    
    for (const auto& item : chars) {
        std::cout << item;
    }
    std::cout << '\n';
}

这个实现的优势：

• 类型安全：避免了sprintf可能出现的格式符不匹配问题
• 安全通用：模板数组引用自动推导长度，不会出现数组越界
• 代码简洁：用范围for和标准库工具，逻辑一目了然
• const正确性：参数val用const修饰，明确表示不会修改输入数组

如果你的环境支持C++20及以上，还可以用更现代的std::format_to，直接将格式化结果写入vector，连中间的string都可以省去：

#include <vector>
#include <format>
#include <iostream>

template <std::size_t N>
void add_chars(std::vector<char>& vec, const unsigned (&val)[N]) {
    for (const auto num : val) {
        // std::format_to直接写入vector的尾部迭代器，高效且简洁
        std::format_to(std::back_inserter(vec), "{}", num);
    }
}

二、更高效的实现方法 #

原始实现的效率瓶颈在于：每次循环都要创建std::string（会触发内存分配），且vector可能因为多次插入而频繁扩容。我们可以通过预先分配内存和减少中间内存分配来优化：

#include <vector>
#include <cstdio>
#include <iostream>

// 编译期计算unsigned int的十进制字符长度，避免运行时额外开销
constexpr std::size_t uint_decimal_length(unsigned num) {
    if (num == 0) return 1;
    std::size_t len = 0;
    while (num > 0) {
        len++;
        num /= 10;
    }
    return len;
}

template <std::size_t N>
void add_chars(std::vector<char>& vec, const unsigned (&val)[N]) {
    // 第一步：预先计算所有数字转换后的总字符长度
    std::size_t total_len = 0;
    for (const auto num : val) {
        total_len += uint_decimal_length(num);
    }
    // 提前给vector预留足够空间，避免多次扩容的内存拷贝
    vec.reserve(vec.size() + total_len);

    // 第二步：用固定大小的缓冲区（足够容纳最大unsigned int的字符串）
    char buf[11]; // unsigned int最大是4294967295，共10位数字，加1位结束符
    for (const auto num : val) {
        // 用snprintf替代sprintf，更安全（不会缓冲区溢出）
        const int count = std::snprintf(buf, sizeof(buf), "%u", num);
        if (count > 0) {
            vec.insert(vec.end(), buf, buf + count);
        }
    }
}

int main() {
    std::vector<char> chars;
    constexpr unsigned val[10] = {1, 200, 3, 4, 5, 6000, 7, 8, 9000, 0};
    add_chars(chars, val);
    
    for (const auto& item : chars) {
        std::cout << item;
    }
    std::cout << '\n';
}

这个实现的效率优化点：

• 预分配内存：通过reserve一次性给vector分配足够空间，避免多次扩容带来的内存拷贝开销
• 减少中间分配：用固定大小的栈缓冲区替代std::string，避免了堆内存的分配和释放
• 编译期计算长度：uint_decimal_length是constexpr函数，对于常量数字可以在编译期算出长度，节省运行时间
• 安全的C风格函数：用snprintf替代sprintf，避免缓冲区溢出的风险

如果追求极致效率，还可以手动实现数字转字符的函数，完全避免调用标准库的格式化函数，不过这种方式代码量会增加，需要权衡可读性和效率。

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