C++中如何让函数模板成为高阶函数调用的一等公民？

函数模板本身是生成具体函数的蓝图，并非可直接传递的实体——编译器需要明确的类型约束才能实例化出对应的函数。以下两种方法无需依赖lambda或std::function类型擦除，仅需调整高阶函数的定义，即可实现调用时直接传递函数模板名的需求：

方法1：显式指定函数指针类型 #

修改高阶函数，让其可调用参数的类型基于容器的迭代器类型明确为函数指针。此时编译器会自动根据该指针类型实例化函数模板，调用时直接传递模板名即可。

#include <vector>
#include <iterator>
#include <algorithm>

template <typename It>
void f(It first, It last) {
    std::for_each(first, last, [](int x) {}); // 示例逻辑
}

void g(std::vector<int>::iterator, std::vector<int>::iterator) {}

// 适配无返回值的函数模板
template <typename C>
void callA(C&& c, void(*func)(std::decay_t<decltype(std::begin(c))>, std::decay_t<decltype(std::begin(c))>)) {
    func(std::begin(c), std::end(c));
}

// 适配有返回值的函数模板（如std::distance）
template <typename C>
auto callA(C&& c, auto(*func)(std::decay_t<decltype(std::begin(c))>, std::decay_t<decltype(std::begin(c))>)) {
    return func(std::begin(c), std::end(c));
}

int main() {
    std::vector<int> c{1,2,3};
    callA(c, f);                          // 正常编译
    callA(c, g);                          // 正常兼容普通函数
    auto dist = callA(c, std::distance);  // 正常获取迭代器间距
}

方法2：模板模板参数配合Functor模板 #

若允许将原函数模板改为Functor类模板，高阶函数可直接接受模板模板参数，自动实例化Functor并调用。这种方式调用同样简洁，但需要修改原函数的定义形式。

#include <vector>
#include <iterator>

// 将原函数模板f改为Functor模板
template <typename It>
struct F {
    void operator()(It first, It last) const {
        // 原f的逻辑实现
    }
};

void g(std::vector<int>::iterator, std::vector<int>::iterator) {}

// 适配Functor模板的高阶函数
template <typename C, template <typename> typename Func>
void callB(C&& c) {
    using It = std::decay_t<decltype(std::begin(c))>;
    Func<It>{}(std::begin(c), std::end(c));
}

// 兼容普通函数的重载版本
template <typename C, typename Func>
void callB(C&& c, Func func) {
    func(std::begin(c), std::end(c));
}

int main() {
    std::vector<int> c;
    callB<std::vector<int>, F>(c); // 调用Functor版本
    callB(c, g);                   // 调用普通函数版本
}

核心原理 #

函数模板本身并非一等公民，但通过给编译器提供明确的类型约束（如方法1的函数指针类型、方法2的Functor模板参数），可以让编译器自动从模板蓝图生成具体的函数实例，从而实现“直接传递模板名”的效果。

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