实现带完美转发的C++20 std::format回调Lambda

需求场景 #

要实现一个lazy_format函数，返回Lambda回调以延迟执行格式化操作，示例用法如下：

auto callback = lazy_format("Hello, my name is {}, my age is {}, my hobby is {}", "Arthur", 8, "Dinosaurs");

// ... 其他业务逻辑

if (ask_about_themselves) {
    std::string response = callback();
}

核心要求：

• 完美转发参数，保留原始类型信息（比如数组引用不能退化为指针）
• 团队规定禁止使用std::vformat（特殊情况除外）
• 其他成员使用时无需额外处理类型问题

初始实现的问题 #

最初的模板实现存在类型匹配错误：

template<typename... Args>
inline auto lazy_format(std::format_string<Args...> fmt, Args&&... args)
{
    return [fmt, ...args = std::forward<Args>(args)]() {
        std::format(fmt, std::forward<Args>(args)...);
    };
}

问题点：捕获的std::format_string模板参数与实际传递给std::format的参数类型不匹配。例如传入const char(&)[7]类型的字符串时，Lambda捕获会丢失数组引用信息，传递给std::format的变成const char* const，不符合格式化器期望的数组引用类型。

参考方案的不足 #

参考调整后的代码解决了数组退化问题，但存在const引用参数被复制而非保留引用的缺陷：

template<typename... Args>
inline auto lazy_format(std::format_string<const std::decay_t<Args>&...> fmt, Args&&... args)
{
    return [fmt=std::move(fmt), ...args=std::forward<Args>(args)]() {
        return std::format(fmt, args...);
    };
}

正确实现方案 #

方案一：用Tuple存储参数并完美转发（安全首选） #

#include <format>
#include <tuple>

template<typename... Args>
inline auto lazy_format(std::format_string<Args...> fmt, Args&&... args)
{
    auto args_tuple = std::forward_as_tuple(std::forward<Args>(args)...);
    return [fmt = std::move(fmt), args_tuple = std::move(args_tuple)]() mutable {
        return std::apply([&fmt](auto&&... forwarded_args) {
            return std::format(fmt, std::forward<decltype(forwarded_args)>(forwarded_args)...);
        }, std::move(args_tuple));
    };
}

核心原理：

• std::forward_as_tuple会保留参数的原始引用类型（左值引用/右值引用），避免数组退化和不必要的复制
• 通过std::apply展开tuple并完美转发给std::format，确保类型完全匹配
• mutable修饰Lambda允许移动tuple，优化右值参数的传递效率

方案二：混合引用+值捕获（需注意生命周期） #

如果不想依赖tuple，可以通过显式区分左值/右值的捕获方式实现：

#include <format>

template<typename... Args>
inline auto lazy_format(std::format_string<Args...> fmt, Args&&... args)
{
    // 左值参数捕获引用，右值参数捕获值，同时保留原始类型信息
    return [fmt = std::move(fmt), &...args = args]() -> std::string {
        return std::format(fmt, std::forward<Args>(args)...);
    };
}

⚠️ 注意：此方式要求原始左值参数的生命周期必须长于Lambda的生命周期，否则会出现悬垂引用问题。如果需要存储临时右值对象，方案一更安全。

效果验证 #

测试数组参数（避免退化）：

const char name[] = "Arthur";
auto callback = lazy_format("Name: {}", name);
// 调用时传递的是const char(&)[7]类型，而非const char*
std::cout << callback() << std::endl;

测试const引用参数（保留引用）：

const int age = 8;
auto callback = lazy_format("Age: {}", std::cref(age));
// 传递的是const int&，不会复制age对象
std::cout << callback() << std::endl;

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