我完全理解你的痛点——要升级老旧日志系统到C++20的现代特性，还要几百份旧代码完全不改动，确实是个棘手的问题。你之前遇到的模板推导失败，核心原因是可变参数包会“吞噬”后面的默认参数，编译器没办法自动区分Args...和std::source_location的边界。

下面我给你一套完美的解决方案，既能保留Logger.print("%d %d", a, b)的原有语法，又能自动推导模板参数，还能正确获取调用位置的源信息：

核心思路 #

把日志函数拆成两层：

1. 对外暴露的兼容接口：完全和旧代码的调用语法一致，负责推导可变参数、获取当前源位置
2. 内部的实现函数：接收源位置和已推导好的参数，完成日志格式化和输出

这样既避开了模板推导的坑，又能100%兼容旧代码。

完整实现代码 #

头文件 Log.hpp #

#pragma once
#include <print>
#include <format>
#include <string>
#include <cctype>
#include <source_location>

struct Log {
    // 对外接口：完全和旧代码调用语法一致！
    template<typename... Args>
    void print(const char* format, Args&&... args) {
        // 在这里获取调用位置的源信息，再传给内部实现
        print_impl(
            format,
            std::forward<Args>(args)...,
            std::source_location::current()
        );
    }

private:
    // 内部实现：处理源位置和日志格式化
    template<typename... Args>
    void print_impl(
        const char* c_format,
        Args&&... args,
        const std::source_location& loc
    ) {
        // 1. 把C风格格式字符串（%d/%s）转成std::format兼容的{}格式
        const auto fmt_str = convert_c_style_format(c_format);
        // 2. 用std::vformat做类型安全的格式化
        const auto msg = std::vformat(
            fmt_str,
            std::make_format_args(std::forward<Args>(args)...)
        );
        // 3. 输出带源位置的日志
        std::println("{}:{} {}", loc.file_name(), loc.line(), msg);
    }

    // 工具函数：C风格格式字符串转std::format格式（可根据需求扩展）
    std::string convert_c_style_format(const char* c_format) const {
        std::string result;
        const char* p = c_format;
        while (*p != '\0') {
            if (*p == '%') {
                ++p;
                if (*p == '%') {
                    // 处理转义的%（比如printf("%%d")要输出%d）
                    result += '%';
                    ++p;
                } else {
                    // 跳过格式符的修饰部分（比如%04d中的04）
                    while (*p != '\0' && !std::isalpha(static_cast<unsigned char>(*p)) && *p != '%') {
                        ++p;
                    }
                    // 替换格式符为{}
                    result += "{}";
                    if (*p != '\0' && std::isalpha(static_cast<unsigned char>(*p))) {
                        ++p;
                    }
                }
            } else {
                result += *p;
                ++p;
            }
        }
        return result;
    }
};

调用示例（完全和旧代码一致） #

#include "Log.hpp"

auto main() -> int {
    auto Logger = Log{};
    const auto a = int{0};
    const auto b = int{1};
    
    // 完全保留原有语法，一行都不用改！
    Logger.print("%s:%d %d %d", "test", 123, a, b);
    Logger.print("a = %d, b = %d", a, b);
    
    return 0;
}

为什么这个方案能解决你的问题？ #

1. 模板推导完全正常：对外的print函数没有std::source_location参数，编译器可以完美推导Args...的类型，不需要你显式指定Logger.print<int,int>(...)
2. 源位置获取正确：在对外接口里调用std::source_location::current()，获取的是你写Logger.print的位置，而不是日志类内部函数的位置
3. 100%兼容旧代码：调用语法和原来完全一致，几百份旧代码不需要任何修改
4. 类型安全的格式化：用C++20的std::format替代老旧的C风格格式化，避免了格式符和参数类型不匹配的隐藏bug

你原来的代码问题分析 #

你之前尝试把std::source_location作为print函数的最后一个默认参数，这会触发模板推导的歧义：编译器不知道Args...应该在哪里结束，会把std::source_location也当成Args的一部分，所以必须显式指定模板参数才能编译通过。

而拆分函数的方式，相当于把“推导参数”和“获取源位置”两个步骤分开，完美绕过了这个推导陷阱。

额外优化建议 #

1. 如果不需要兼容C风格格式字符串，可以直接去掉convert_c_style_format函数，让print直接接受std::format的格式字符串，性能会更高
2. 可以给日志添加级别（info/warn/error），只需要重载print函数，比如加一个Logger.warn(...)，逻辑和print完全一致
3. 如果要输出到文件而不是控制台，只需要修改内部实现里的std::println，换成文件输出流即可