c++ - 为什么在传递 lambda 而不是函数指针时无法推断模板参数

Question

我有一个冒泡排序函数，它接受一个数组、一个比较函数和一个指示是否应该对数组进行倒序排序的 bool 值。它是一个模板函数，支持任何数据类型，并会自动推导数组大小。

当指定比较函数时，如果我传递函数指针，编译器会自动推导出数组的数据类型，这很棒。但是如果我改为传递 lambda，它不会自动推导。我必须明确指定数据类型，或者 static_cast lambda 为 fnCompare_t<double> .

这背后的原因是什么？因为根据this post ，只要 lambda 不捕获，它就可以像普通的函数指针一样使用，但似乎并非总是如此？为什么在这种情况下会有所不同？

#include <iostream>
using namespace std;

template <typename T>
using fnCompare_t = int(*)(T const &, T const &);

template <typename T, size_t count>
inline void BubbleSort(
    T(&array)[count],
    fnCompare_t<T> fnCompare,
    bool reverse)
{
    cout << "TODO: Implement BubbleSort" << endl;
}

double doubleArray[] = {
    22.3, 11.2, 33.21, 44.2, 91.2, 15.2, 77.1, 8.2
};

int CompareDouble(double const & a, double const & b)
{
    return a > b ? 1 : a == b ? 0 : -1;
}

int main()
{
    auto fnCompare = [](double const & a, double const & b) -> int {
        return a > b ? 1 : a < b ? -1 : 0;
    };
    // compile OK:
    BubbleSort(doubleArray, CompareDouble, false);
    BubbleSort(doubleArray, static_cast<fnCompare_t<double>>(fnCompare), false);
    BubbleSort<double>(doubleArray, fnCompare, false);
    // compile error, could not deduce template argument:
    //BubbleSort(doubleArray, fnCompare, false);
    return 0;
}

Answer 1

原因是因为在使用推导时无法对模板化参数进行隐式转换。经典的例子是:

template <class T>
T min(T x, T y);

调用此函数为 min(1, 3.0)将导致失败。因为对于这两个参数，它都试图找到一个 T获得完美匹配，但失败了。如果您明确指定模板参数，它就可以工作:min<double>(1, 3.0) .如果您指定 T，在您的示例中也是如此明确地说它会起作用。

为您的函数编写签名的惯用方法是:

template <typename Iter, typename F>
inline void BubbleSort(
    Iter b, Iter e,
    F fnCompare,
    bool reverse)

但是，这会丢弃编译时间长度信息。如果你想保留它，你可以这样做:

template <typename T, size_t count, typename F>
inline void BubbleSort(
    T(&array)[count],
    F fnCompare,
    bool reverse);

尽管您至少应该考虑使用 std::array而不是 C 风格的数组，这将使签名不那么难看，并且还有其他好处。

这可能看起来很奇怪，因为我们没有在我们的类别签名中“验证”具有正确签名的比较器。但这在 C++ 中是正常的，如果比较器不正确，那么它会在使用时失败，并且仍然是编译时错误。另请注意，当您尝试依赖 lambda 隐式转换为函数指针时，您会受到不必要的限制:lambda 仅转换为具有相同签名的函数指针。即使 lambda 的输出可以隐式转换为函数指针的输出，您的 lambda 也不会隐式转换，即使 lambda 仍然可以使用!

作为最后的最后说明，传递仿函数通常更好，因为它对性能更好。比较器通常是小函数，通常会被内联。但是在你的版本中，比较器通常不会被内联，在我的版本中它会(因为我保留了 lambda 的原始类型，而你没有)。