c++ - 函数模板作为参数

Question

我一直在尝试在 C++11 中实现函数 map来自 Python。它似乎适用于任何类型的可调用对象，但如果我希望它与函数模板一起使用，我必须指定模板类型参数。示例:

#include <iostream>
#include <list>

template<typename T>
T abs(T x)
{
    return x < 0 ? -x : x;
}

int main()
{
    std::list<int> li = { -1, -2, -3, -4, -5 };
    for (auto i: map(&abs<int>, li))
    {
        std::cout << i << std::endl;
    }
}

它工作正常，但我希望它能推断出 int来自函数第二个参数的参数，因此可以写成:

for (auto i: map(&abs, li))
{
    std::cout << i << std::endl;
}

我的 map函数写成:

template<typename Callable, typename Container>
auto map(const Callable& function, Container&& iter)
    -> MapObject<Callable, Container>
{
    return { function, std::forward<Container>(iter) };
}

哪里MapObject是实现的一部分，在这里不是真正的问题。我如何更改其定义，以便 Callable 的模板类型对象可以从 Container 推导出来目的？例如map怎么能知道我们必须使用 abs<int>对于给定的 abs当 list<int>给定了吗？

Answer 1

It works fine, but I would like it to deduce the int parameter from the second argument of the function, and hence be able to write:

for (auto i: map(&abs, li))
{
    std::cout << i << std::endl;
}

问题是 abs不是函数，而是函数模板，因此没有address-of abs , 虽然有 &abs<int> , 自 abs<int> (特化)确实是一个函数(从模板生成)。

现在的问题是您真正想要解决的问题，特别是您必须认识到 C++ 是一种静态类型的语言，而 Python 是一种动态类型的语言。我不清楚你在不同层面上想要达到什么目的。例如，函数 map在 python 中有一个等效项 std::transform在 C++ 中:

a = [ 1, 2, 3 ]
a = map(lambda x: 2*x, a)

std::vector<int> v{1,2,3};
std::transform(v.begin(),v.end(),v.begin(),[](int x){ return 2*x; });

我稍微作弊了，因为在 Python 中它会创建一个不同的容器，但在 C++ 中 transform在迭代器级别工作并且不知道容器，但您可以类似地获得相同的效果:

std::vector<int> v{1,2,3};
std::vector<int> result;
// optionally: result.reserve(v.size());
std::transform(v.begin(),v.end(),
               std::back_inserter(result),
               [](int x) { return 2*x; });

我建议您学习该语言中的习语，而不是尝试从其他语言中实现习语...

顺便说一句，如果您愿意让用户指定传递给 map 的仿函数的类型函数，那么您只需传递模板的名称，让编译器找出您需要的特化:

template <typename Container>
auto map(Container && c, 
         typename Container::value_type (*f)(typename Container::value_type))
     -> MapObject<Callable<T>,Container>;
template <typename T>
T abs(T value);

int main() {
   std::vector<int> v{1,2,3,4};
   map(v,abs);
}

这不像您尝试做的那样通用，因为它只接受函数指针和具体类型(这甚至比 std::transform 更不通用)并且它的工作方式与编译器看到 abs 时一样。 (没有 & )它将把它解析为模板，从而解析为一组特化。然后它将使用预期的类型来选择一个特化并将其传入。编译器将隐式执行 &abs<int>。在这种情况下适合你。

另一种更通用的替代方法是不使用函数，而是使用仿函数。考虑到这一点，您可以定义 abs作为:

struct abs {
   template <typename T>
   T operator()(T t) { ...}
};

然后传递仿函数的拷贝而不是函数指针。无需确定要在传递对象的地方使用的重载 abs进入map功能，仅在使用时使用。调用方看起来像:

for (auto& element : map(container,abs()))

额外的一组括号创建一个 abs 类型的对象并将其传入。

总的来说，我会尽量避免这种情况。这是一件有趣的事情，您可能会找到一个好的解决方案，但这将困难并且需要相当多的 c++ 专业知识。因为它不受语言支持，所以您将不得不设计一些在该语言内工作的东西，并且需要在不同的特性或语法上做出妥协。了解选项本身就是一个难题，更难理解折衷方案，更难找到好的解决方案。而好的解决方案可能会比等效的惯用 C++ 代码更糟糕。

如果你用 C++ 编程，就用 C++ 编程。尝试通过 C++ 编译器编写 python 代码可能会给您带来 C++ 的痛苦和 python 的性能。