C++中如何将模板函数的类型指定为另一函数的参数？

你遇到的核心问题是：模板函数本身不是一个具体的函数，而是生成函数的“蓝图”。直接传递add或subtract时，编译器无法确定要实例化出哪个具体的函数版本，自然没法推导参数类型。

而你觉得add和subtract“类型相同”，其实是指它们的特定实例化版本（比如add<int, int>和subtract<int, int>）具有相同的函数类型——但模板本身并不属于某个固定类型。

下面是几种可行的解决方式：

方案1：让Process成为模板函数（最灵活） #

把Process定义为模板，让编译器自动推导传入的函数实例类型：

template<typename T, typename U>
auto add(T left, U right) -> decltype(left + right) { return left + right; }

template<typename T, typename U>
auto subtract(T left, U right) -> decltype(left - right) { return left - right; }

// 用模板参数接收任意可调用对象（包括模板函数的实例）
template<typename Operation>
void Process(Operation operation) {
    // 示例：调用operation，编译器会根据传入的参数推导模板函数的实例
    auto result = operation(10, 5);
    // 后续逻辑...
}

void DoAdd() {
    // 直接传模板名，编译器会在Process内部调用时推导实例化类型
    Process(add);
    Process(subtract);
    
    // 也可以显式指定实例版本，更明确
    Process(add<int, double>);
    Process(subtract<double, int>);
}

这种方式支持所有可调用对象（模板函数、普通函数、lambda、仿函数），是C++中处理这类场景的常规做法。

方案2：使用std::function指定固定签名 #

如果你希望Process只接受特定签名的函数（比如两个int返回int），可以用std::function明确限定：

#include <functional>

template<typename T, typename U>
auto add(T left, U right) -> decltype(left + right) { return left + right; }

template<typename T, typename U>
auto subtract(T left, U right) -> decltype(left - right) { return left - right; }

// 限定operation是“接受两个int，返回int”的函数
void Process(std::function<int(int, int)> operation) {
    int result = operation(10, 5);
    // 后续逻辑...
}

void DoAdd() {
    // 必须显式实例化模板函数，匹配std::function的签名
    Process(add<int, int>);
    Process(subtract<int, int>);
}

这种方式的缺点是灵活性差，只能处理签名完全匹配的函数。

方案3：C++20 用概念约束（更优雅） #

如果使用C++20及以上版本，可以用**概念（Concepts）**来约束operation是符合二元运算的可调用对象，既保留灵活性又能做类型检查：

#include <concepts>

template<typename T, typename U>
auto add(T left, U right) -> decltype(left + right) { return left + right; }

template<typename T, typename U>
auto subtract(T left, U right) -> decltype(left - right) { return left - right; }

// 定义概念：二元运算可调用对象
template<typename Op, typename T, typename U>
concept BinaryOp = requires(Op op, T a, U b) {
    { op(a, b) } -> std::common_with<decltype(a + b)>;
};

// 使用概念约束参数，同时让模板推导类型
template<typename T = int, typename U = int, BinaryOp<T, U> Op>
void Process(Op operation) {
    auto result = operation(T{}, U{});
    // 后续逻辑...
}

void DoAdd() {
    Process(add);
    Process(subtract);
}

概念可以更精准地限定operation的行为，避免传入不符合要求的可调用对象。

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