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 就是为了在高性能场景下替代这些方案而设计的。
头文件
#include <charconv>核心接口
to_chars(数值转字符串)
// 整数版本
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(字符串转数值)
// 整数版本
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);返回值结构
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(默认) | 自动选择最短表示 |
基本示例
#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_chars | std::to_string/std::stoi | sprintf/sscanf | std::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
编译器支持情况
| 编译器 | 整数版本 | 浮点数版本 |
|---|---|---|
| GCC | 8.0 | 11.0 |
| Clang | 7.0 | 14.0(libc++) |
| MSVC | 19.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 终止的——但这正是它快的原因。