C++高阶函数模板：按值与万能引用接收函数参数的差异

两种写法的核心差异来自值语义与引用语义的本质区别，结合模板推导、完美转发的特性，具体差异可以拆成四点：

• 传参开销不同：按值写法Fn fn传参时必然会构造一份可调用对象的独立副本——传入左值时触发拷贝构造，传入右值时触发移动构造。如果可调用对象是捕获了大体积容器、重型资源的lambda，或是自定义的大尺寸函数对象，这部分开销不可忽略；万能引用写法Fn&& fn直接绑定到传入的原对象，不会触发拷贝/移动，传参过程零额外开销。
• 语义保留能力不同：万能引用配合std::forward可以完整保留传入对象的const/volatile限定、左值/右值属性，转发调用时能精准匹配原对象对应的重载；按值接收的fn是函数栈上的独立局部变量，永远是无cv限定的左值，完全丢失原对象的cv限定和值类别信息。
• 副作用影响范围不同：按值接收时，函数内部对函数对象状态的修改（比如修改mutable lambda的捕获值、修改函数对象的成员变量）只会作用在局部副本上，完全不影响外部原对象；万能引用绑定到外部原对象时，如果传入的是左值，内部对可调用对象的修改会直接作用在外部原对象上。
• 类型支持范围不同：按值接收要求可调用对象必须可拷贝或可移动，如果遇到拷贝构造、移动构造全被删除的函数对象，会直接编译失败；万能引用不需要构造新对象，天然支持这类不可拷贝、不可移动的类型。

两种写法行为不一致的典型场景 #

场景1：带状态的mutable lambda调用 #

mutable lambda的捕获变量修改是作用在lambda对象自身的成员上的，两种写法的调用结果完全不同：

#include <iostream>

// 万能引用版本
template <typename Fn, typename... Args>
void apply_ref(Fn&& fn, Args&&... args) {
    std::forward<Fn>(fn)(std::forward<Args>(args)...);
}

// 按值接收版本
template <typename Fn, typename... Args>
void apply_val(Fn fn, Args&&... args) {
    std::forward<Fn>(fn)(std::forward<Args>(args)...);
}

int main() {
    auto counter = [cnt = 0]() mutable {
        cnt++;
        std::cout << "lambda内部cnt值：" << cnt << '\n';
    };

    std::cout << "=== 按值版本连续调用2次 ===\n";
    apply_val(counter);
    apply_val(counter);

    std::cout << "=== 万能引用版本连续调用2次 ===\n";
    apply_ref(counter);
    apply_ref(counter);
}

运行输出：

=== 按值版本连续调用2次 ===
lambda内部cnt值：1
lambda内部cnt值：1
=== 万能引用版本连续调用2次 ===
lambda内部cnt值：1
lambda内部cnt值：2

按值版本每次调用都会拷贝一份新的lambda，修改的是副本的cnt，原lambda状态完全不变，所以两次输出都是1；万能引用版本直接绑定原lambda，修改的是原对象的cnt，状态会被保留。

场景2：不可拷贝、不可移动的函数对象 #

如果自定义函数对象禁用了拷贝和移动构造，按值版本根本无法通过编译：

struct NoCopyMove {
    NoCopyMove() = default;
    NoCopyMove(const NoCopyMove&) = delete;
    NoCopyMove(NoCopyMove&&) = delete;
    void operator()() {
        std::cout << "调用不可拷贝移动的函数对象\n";
    }
};

int main() {
    NoCopyMove f;
    apply_ref(f); // 编译、运行正常
    // apply_val(f); // 编译报错：尝试调用被删除的拷贝构造函数
}

场景3：按cv限定、值类别重载调用运算符的函数对象 #

如果函数对象针对不同限定、不同值类别重载了operator()，按值版本永远无法正确匹配到对应重载：

struct OverloadedFunctor {
    void operator()() &  { std::cout << "调用非const左值重载\n"; }
    void operator()() const& { std::cout << "调用const左值重载\n"; }
    void operator()() && { std::cout << "调用右值重载\n"; }
};

int main() {
    OverloadedFunctor f;
    const OverloadedFunctor cf;

    std::cout << "--- 万能引用版本 ---\n";
    apply_ref(f);          // 匹配非const左值重载
    apply_ref(cf);         // 匹配const左值重载
    apply_ref(OverloadedFunctor{}); // 匹配右值重载

    std::cout << "--- 按值版本 ---\n";
    apply_val(f);          // 永远匹配非const左值重载
    apply_val(cf);         // 拷贝生成的局部fn是非const左值，还是匹配非const重载
    apply_val(OverloadedFunctor{}); // 局部fn是左值，依然匹配非const重载
}

延伸问题：万能引用是不是可调用对象形参的万能选择？ #

不是，选择哪种写法完全取决于函数自身的语义需求：

• 如果你的函数逻辑是同步调用可调用对象、不需要持有可调用对象的副本（比如类似std::invoke、范围遍历中的回调、即时执行的逻辑），万能引用+完美转发是最优选择：开销最低、支持的类型最广、语义保留最完整，能最大化泛型能力。注意如果函数内部需要多次调用可调用对象，不要在非最后一次调用时使用std::forward转发fn，避免右值对象被提前移走导致后续调用异常。
• 如果你的函数逻辑是需要持有可调用对象的副本（比如异步任务提交、跨线程调度、需要保存回调延后执行），按值接收反而更符合语义：你拿到的是独立副本，不受外部原对象生命周期、状态修改的影响，虽然有拷贝/移动开销，但语义正确性优先级高于泛型能力和开销。

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