如何修改C++ std::format标准类型格式化及自定义千位分隔符等行为？

一、修改标准类型的默认格式化逻辑 #

std::format的标准类型格式化特化不可直接修改，因为标准库明确禁止用户替换这些内置特化。但可以通过两种方式实现类似“定制”的效果：

1. 自定义包装类 + 格式化器特化 #

创建一个简单的包装类包裹目标标准类型，然后为该包装类实现std::formatter特化，从而完全掌控格式化逻辑。

示例代码：

#include <format>
#include <string>

// 包装整数类型的类
template<typename T>
struct CustomInt {
    T value;
    explicit CustomInt(T v) : value(v) {}
};

// 为CustomInt特化formatter
template<typename T>
struct std::formatter<CustomInt<T>> : std::formatter<std::string> {
    template<typename FormatContext>
    auto format(const CustomInt<T>& obj, FormatContext& ctx) const {
        // 自定义逻辑：将整数转为大写十六进制字符串
        std::string hex_str = std::format("{:X}", obj.value);
        return std::formatter<std::string>::format(hex_str, ctx);
    }
};

// 使用方式
int main() {
    int num = 255;
    std::string s = std::format("定制格式化结果：{}", CustomInt(num));
    // 输出：定制格式化结果：FF
}

2. 临时自定义处理函数 #

如果仅需在某一处修改格式化逻辑，可直接在传入std::format前用自定义函数处理数据：

#include <format>
#include <string>
#include <algorithm>

std::string reverse_num_str(int num) {
    std::string s = std::to_string(num);
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    int num = 1234;
    std::string result = std::format("反转后的数字：{}", reverse_num_str(num));
    // 输出：反转后的数字：4321
}

二、为整数/浮点数添加千位分隔符 #

这是最常用的自定义格式化需求，以下是具体实现：

1. 整数的千位分隔符 #

通过特化std::formatter，在format函数中手动插入分隔符：

#include <format>
#include <string>

template<typename T>
struct std::formatter<T, char> requires std::integral<T> {
    // 继承默认格式化选项（宽度、填充等）
    std::formatter<std::string, char> base;

    template<typename ParseContext>
    constexpr auto parse(ParseContext& ctx) {
        return base.parse(ctx);
    }

    template<typename FormatContext>
    auto format(T value, FormatContext& ctx) const {
        std::string num_str = std::to_string(value);
        const bool is_negative = num_str.front() == '-';
        const size_t start = is_negative ? 1 : 0;

        // 从右往左每三位插入逗号
        for (size_t i = num_str.size() - 3; i > start; i -= 3) {
            num_str.insert(i, ",");
        }

        return base.format(num_str, ctx);
    }
};

// 使用方式
int main() {
    int64_t large_num = 1234567890;
    std::string result = std::format("带千位分隔符的整数：{}", large_num);
    // 输出：带千位分隔符的整数：1,234,567,890
}

2. 浮点数的千位分隔符 #

浮点数需要拆分整数和小数部分分别处理，再拼接结果：

#include <format>
#include <string>
#include <sstream>
#include <cmath>

template<typename T>
struct std::formatter<T, char> requires std::floating_point<T> {
    std::formatter<std::string, char> base;
    int precision = 2; // 默认保留两位小数

    template<typename ParseContext>
    constexpr auto parse(ParseContext& ctx) {
        auto it = ctx.begin();
        // 解析用户指定的精度（比如:.4f中的4）
        if (it != ctx.end() && *it == '.') {
            ++it;
            precision = 0;
            while (it != ctx.end() && std::isdigit(*it)) {
                precision = precision * 10 + (*it - '0');
                ++it;
            }
        }
        return base.parse(ctx);
    }

    template<typename FormatContext>
    auto format(T value, FormatContext& ctx) const {
        // 拆分整数与小数部分
        const T int_part = std::trunc(value);
        const T frac_part = std::abs(value - int_part);

        // 处理整数部分的千位分隔符
        std::string int_str = std::to_string(static_cast<int64_t>(int_part));
        const bool is_negative = int_str.front() == '-';
        const size_t start = is_negative ? 1 : 0;
        for (size_t i = int_str.size() - 3; i > start; i -= 3) {
            int_str.insert(i, ",");
        }

        // 处理小数部分
        std::ostringstream oss;
        oss.precision(precision);
        oss << std::fixed << frac_part;
        const std::string frac_str = oss.str().substr(2); // 去掉开头的"0."

        // 拼接最终结果
        const std::string result = int_str + "." + frac_str;
        return base.format(result, ctx);
    }
};

// 使用方式
int main() {
    double pi = 3.1415926;
    std::string result1 = std::format("带千位分隔符的浮点数：{}", pi);
    // 输出：带千位分隔符的浮点数：3.14
    std::string result2 = std::format("保留4位小数：{:.4}", 123456.789);
    // 输出：保留4位小数：123,456.7890
}

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