std::to_chars 与 std::from_chars ​

什么是 to_chars 和 from_chars ​

std::to_chars 和 std::from_chars 是 C++17 在 <charconv> 头文件中引入的底层数值与字符串互转函数。它们的设计目标是提供最快速、最简洁的数值转换,具有以下特点:

  • 不依赖 locale:不受系统区域设置影响(不会因为德语环境把小数点变成逗号)
  • 不分配内存:直接在调用者提供的缓冲区上操作
  • 不抛异常:通过返回值中的错误码报告错误
  • 往返保证:to_chars 输出的字符串可以被 from_chars 精确还原(同一实现内)

在此之前,C++ 中数值和字符串的互转手段很多(std::to_string、std::stoi、sprintf、sscanf、std::stringstream 等),但都有各种问题:依赖 locale、可能分配内存、接口不统一、性能不够好。to_chars/from_chars 就是为了在高性能场景下替代这些方案而设计的。

头文件 ​

cpp
#include <charconv>

核心接口 ​

to_chars(数值转字符串) ​

cpp
// 整数版本
std::to_chars_result to_chars(char* first, char* last, 整数类型 value, int base = 10);

// 浮点数版本
std::to_chars_result to_chars(char* first, char* last, 浮点类型 value);
std::to_chars_result to_chars(char* first, char* last, 浮点类型 value, std::chars_format fmt);
std::to_chars_result to_chars(char* first, char* last, 浮点类型 value, std::chars_format fmt, int precision);

from_chars(字符串转数值) ​

cpp
// 整数版本
std::from_chars_result from_chars(const char* first, const char* last, 整数类型& value, int base = 10);

// 浮点数版本
std::from_chars_result from_chars(const char* first, const char* last, 浮点类型& value,
                                  std::chars_format fmt = std::chars_format::general);

返回值结构 ​

cpp
struct to_chars_result {
    char* ptr;      // 成功时指向最后写入字符的下一位置;失败时指向 last
    std::errc ec;   // 错误码,成功时为 std::errc{}
};

struct from_chars_result {
    const char* ptr;  // 指向第一个未解析的字符
    std::errc ec;     // 错误码
};

浮点格式枚举 ​

std::chars_format对应 printf 格式说明
scientific%e科学计数法
fixed%f定点表示
hex%a(无 0x 前缀)十六进制浮点
general%g(默认)自动选择最短表示

基本示例 ​

cpp
#include <iostream>
#include <charconv>
#include <string>
#include <string_view>
#include <system_error>
#include <array>
#include <cstring>

// ============================
// 示例1:整数转字符串(to_chars)
// ============================

void int_to_chars_demo() {
    char buf[32];  // 手动提供缓冲区

    // 十进制
    int value = 12345;
    auto [ptr, ec] = std::to_chars(buf, buf + sizeof(buf), value);
    if (ec == std::errc{}) {
        std::string_view result(buf, ptr - buf);  // 用 ptr 计算实际长度
        std::cout << "十进制: " << result << std::endl;  // 12345
    }

    // 十六进制
    auto [ptr2, ec2] = std::to_chars(buf, buf + sizeof(buf), value, 16);
    if (ec2 == std::errc{}) {
        std::string_view result(buf, ptr2 - buf);
        std::cout << "十六进制: " << result << std::endl;  // 3039
    }

    // 二进制
    auto [ptr3, ec3] = std::to_chars(buf, buf + sizeof(buf), value, 2);
    if (ec3 == std::errc{}) {
        std::string_view result(buf, ptr3 - buf);
        std::cout << "二进制: " << result << std::endl;  // 11000000111001
    }

    // 负数
    int neg = -42;
    auto [ptr4, ec4] = std::to_chars(buf, buf + sizeof(buf), neg);
    if (ec4 == std::errc{}) {
        std::string_view result(buf, ptr4 - buf);
        std::cout << "负数: " << result << std::endl;  // -42
    }
}

// ============================
// 示例2:字符串转整数(from_chars)
// ============================

void chars_to_int_demo() {
    // 基本解析
    std::string_view str = "12345";
    int value = 0;
    auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(), value);
    if (ec == std::errc{}) {
        std::cout << "解析结果: " << value << std::endl;  // 12345
    }

    // 部分解析(遇到非数字字符停止)
    std::string_view str2 = "42abc";
    int value2 = 0;
    auto [ptr2, ec2] = std::from_chars(str2.data(), str2.data() + str2.size(), value2);
    if (ec2 == std::errc{}) {
        std::cout << "部分解析: " << value2 << std::endl;  // 42
        std::cout << "剩余: " << std::string_view(ptr2, str2.data() + str2.size() - ptr2) << std::endl;  // abc
    }

    // 十六进制解析
    std::string_view hex_str = "ff";
    int hex_val = 0;
    auto [ptr3, ec3] = std::from_chars(hex_str.data(), hex_str.data() + hex_str.size(), hex_val, 16);
    if (ec3 == std::errc{}) {
        std::cout << "十六进制 ff = " << hex_val << std::endl;  // 255
    }

    // 错误处理
    std::string_view bad = "not_a_number";
    int bad_val = 0;
    auto [ptr4, ec4] = std::from_chars(bad.data(), bad.data() + bad.size(), bad_val);
    if (ec4 == std::errc::invalid_argument) {
        std::cout << "无效输入" << std::endl;
    }

    // 溢出处理
    std::string_view overflow = "99999999999999999999";
    int overflow_val = 0;
    auto [ptr5, ec5] = std::from_chars(overflow.data(), overflow.data() + overflow.size(), overflow_val);
    if (ec5 == std::errc::result_out_of_range) {
        std::cout << "溢出" << std::endl;
    }
}

// ============================
// 示例3:浮点数转换
// ============================

void float_demo() {
    char buf[64];

    // 浮点数转字符串(默认格式:最短表示)
    double pi = 3.141592653589793;
    auto [ptr, ec] = std::to_chars(buf, buf + sizeof(buf), pi);
    if (ec == std::errc{}) {
        std::string_view result(buf, ptr - buf);
        std::cout << "pi: " << result << std::endl;  // 3.141592653589793
    }

    // 定点格式,指定精度
    auto [ptr2, ec2] = std::to_chars(buf, buf + sizeof(buf), pi,
                                      std::chars_format::fixed, 4);
    if (ec2 == std::errc{}) {
        std::string_view result(buf, ptr2 - buf);
        std::cout << "pi (fixed, 4位): " << result << std::endl;  // 3.1416
    }

    // 科学计数法
    double big = 1.23e15;
    auto [ptr3, ec3] = std::to_chars(buf, buf + sizeof(buf), big,
                                      std::chars_format::scientific);
    if (ec3 == std::errc{}) {
        std::string_view result(buf, ptr3 - buf);
        std::cout << "科学计数法: " << result << std::endl;  // 1.23e+15
    }

    // 字符串转浮点数
    std::string_view float_str = "3.14159";
    double parsed = 0.0;
    auto [ptr4, ec4] = std::from_chars(float_str.data(),
                                        float_str.data() + float_str.size(), parsed);
    if (ec4 == std::errc{}) {
        std::cout << "解析浮点: " << parsed << std::endl;  // 3.14159
    }
}

// ============================
// 示例4:往返转换(round-trip)
// ============================

void roundtrip_demo() {
    double original = 0.1 + 0.2;  // 经典的浮点精度问题

    // 转为字符串
    char buf[64];
    auto [ptr, ec] = std::to_chars(buf, buf + sizeof(buf), original);
    std::string_view str(buf, ptr - buf);
    std::cout << "to_chars: " << str << std::endl;

    // 从字符串还原
    double restored = 0.0;
    std::from_chars(str.data(), str.data() + str.size(), restored);

    // 验证往返精度
    std::cout << "original == restored? " << std::boolalpha
              << (original == restored) << std::endl;  // true
}

int main() {
    std::cout << "=== 整数转字符串 ===" << std::endl;
    int_to_chars_demo();

    std::cout << "\n=== 字符串转整数 ===" << std::endl;
    chars_to_int_demo();

    std::cout << "\n=== 浮点数转换 ===" << std::endl;
    float_demo();

    std::cout << "\n=== 往返转换 ===" << std::endl;
    roundtrip_demo();

    return 0;
}

与传统方案的对比 ​

特性to_chars/from_charsstd::to_string/std::stoisprintf/sscanfstd::stringstream
Locale 依赖无无依赖当前 locale依赖当前 locale
内存分配无(用户提供缓冲区)分配 string用户提供缓冲区内部分配
异常无(错误码)抛异常返回值设置流状态
性能极快中等快慢
浮点往返精度保证不保证需要特殊格式需要特殊设置
接口类型安全类型安全类型安全格式字符串(不安全)类型安全

适用场景 ​

  • JSON/XML/CSV 等数据格式的序列化和反序列化(需要 locale 无关的数值转换)
  • 高性能网络协议的数据编解码
  • 数据库驱动中的数值字段处理
  • 科学计算中浮点数的精确存储和还原
  • 任何对性能敏感的数值-字符串互转场景

常见问题 ​

to_chars 输出的字符串是 null 终止的吗?

不是。to_chars 只写入数值字符,不添加 \0。如果你需要 null 终止的字符串,要手动在 ptr 位置写入 \0,或者用 string_view(buf, ptr - buf) 来限定范围。

缓冲区不够大怎么办?

to_chars 返回的 ec 会是 std::errc::value_too_large。不会越界写入,是安全的。对于 int 类型,32 字节的缓冲区足够;对于 double,64 字节的缓冲区足够。

from_chars 会跳过前导空格吗?

不会。from_chars 不跳过任何空白字符。如果输入以空格开头(如 " 42"),会返回 std::errc::invalid_argument。这和 sscanf、stoi 不同(它们会跳过前导空格)。

浮点数的 from_chars 所有编译器都支持吗?

整数版本的 to_chars/from_chars 在主流编译器中很早就支持了。浮点数版本的支持较晚:MSVC 从 VS 2017 15.8 开始支持,GCC 从 11.0 开始完整支持,Clang/libc++ 从 14.0 开始支持。

注意事项 ​

  • to_chars 不添加 null 终止符,使用结果时要用返回的 ptr 确定实际长度
  • from_chars 不跳过前导空格,输入必须直接以数字(或负号)开头
  • from_chars 不识别 + 号前缀("+42" 会解析失败),只识别 - 号
  • from_chars 解析十六进制时不接受 0x 前缀
  • 浮点数的往返精度保证仅限于同一编译器实现内
  • 错误检查用 ec == std::errc{}(注意是默认构造的 errc,不是 0)
  • C++23 起 to_chars/from_chars 的整数版本变为 constexpr

编译器支持情况 ​

编译器整数版本浮点数版本
GCC8.011.0
Clang7.014.0(libc++)
MSVC19.14 (VS 2017 15.7)19.15 (VS 2017 15.8)

总结 ​

std::to_chars 和 std::from_chars 是 C++17 提供的高性能、低级别的数值-字符串互转函数。它们不依赖 locale、不分配内存、不抛异常,是目前 C++ 标准库中最快的数值转换方式。对于整数,支持 2 到 36 的任意进制;对于浮点数,支持定点、科学计数法、十六进制等多种格式,并保证往返精度(同一实现内 to_chars 的输出可以被 from_chars 精确还原)。它们是 JSON 解析器、网络协议编解码、数据序列化等高性能场景的理想选择。唯一的不便是接口比较底层——需要手动管理缓冲区、手动检查错误码、输出不是 null 终止的——但这正是它快的原因。