模板化函数可以作为另一个函数的模板参数吗？

Question

我以为我会对一些排序算法进行基准测试，但我一定是做错了模板：

代码

#include <iostream>
#include <vector>

template <typename ForwardIterator>
void dummysort(ForwardIterator begin_it, ForwardIterator end_it)
{
    // pretend to use these and sort stuff
    ++begin_it;
    ++end_it;
}

template<typename SortFunc>
void benchmark(const char* name, SortFunc sort_func, std::vector<int> v)
{
    std::cout << name << std::endl;
    sort_func(v.begin(), v.end());
}

int main()
{
    std::vector<int> first = {3, 2, 1};

    benchmark("bubblesort", dummysort, first);
}

错误

10:48 $ clang -std=c++14 tmp.cpp
tmp.cpp:30:5: error: no matching function for call to 'benchmark'
    benchmark("bubblesort", dummysort, first);
    ^~~~~~~~~
tmp.cpp:20:6: note: candidate template ignored: couldn't infer template argument 'SortFunc'
void benchmark(const char* name, SortFunc sort_func, std::vector<int> v)
     ^
1 error generated.

编译器信息

10:47 $ clang --version
Apple LLVM version 8.1.0 (clang-802.0.42)
Target: x86_64-apple-darwin16.0.0
Thread model: posix
InstalledDir: /Library/Developer/CommandLineTools/usr/

如果我“取消模板化”dummysort，它会起作用。

void dummysort(std::vector<int>::iterator begin_it, std::vector<int>::iterator end_it)

问题

有什么方法可以让它通用，或者，如果没有，有人可以给我一个很好的解释或类似于this answer的思想实验吗？

Answer 1

正如 nwp 所解释的，模板函数不是函数。只是构造函数的秘诀。

所以你不能通过配方

benchmark("bubblesort", dummysort, first);

但是您可以通过说明类型来从配方中构造函数；我是说

benchmark("bubblesort", dummysort<std::vector<int>::iterator>, first);

有效，但我觉得它有点难看。

我建议你另一种解决方案：代替模板函数，构造一个类（或结构），其中包含模板operator()；像

struct dummySort
 {
   template <typename FI>
   void operator() (FI begin_it, FI end_it)
    {
      ++begin_it;
      ++end_it; 
    }
 };

通过这种方式，您可以调用 benchmark() 并传递此类型的对象，而无需说明迭代器的类型：这是对 benchmark() 内部的运算符的调用选择正确的类型并构造正确的运算符。

以下是完整的编译示例

#include <iostream>
#include <vector>

struct dummySort
 {
   template <typename FI>
   void operator() (FI begin_it, FI end_it)
    { ++begin_it; ++end_it; }
 };

template <typename SortFunc>
void benchmark (char const * name, SortFunc sort_func, std::vector<int> v)
 {
   std::cout << name << std::endl;
   sort_func(v.begin(), v.end());
 }

int main()
 {
   std::vector<int> first = {3, 2, 1};

   benchmark("bubblesort", dummySort{}, first);
 }

Answer 2

有几种方法可以解决这个问题。

1. 您可以为dummysort 显式指定模板参数，也可以将static_cast 指定为适当的函数指针类型。对我来说，这是一个非常糟糕的解决方案，因为它锁定了特定的重载选择，而不是依赖于语言的重载规则。如果您更改其他参数或类型，您可能会得到（最佳情况下）损坏的代码或（最坏情况下）有效但做一些意外的代码

2. 你可以将你的函数模板提升为一个函数object，它有一个调用操作符模板：

   struct dummysort_t {
       template <typename ForwardIterator>
       void operator()(ForwardIterator begin_it, ForwardIterator end_it) const {
           /* ... */
       }
   } constexpr dummysort{}; // in C++17, also mark inline
   

   这使您可以直接将dummysort 传递给您的函数模板，并且具有相同的预期行为。此解决方案的缺点是，如果您不拥有 dummysort，这当然是不可行的，如果您使用 dummysort 作为自定义点，则需要做更多的工作才能做到这一点有预期的行为。

3. 您可以将其包装在 lambda 中。由于我们要复制迭代器，所以简单的形式就可以了：

   [](auto b, auto e) { dummysort(b, e); }
   

   这会延迟 dummysort 的模板实例化，直到另一个函数模板实际调用它。这为您提供了您想要的确切行为，并且适用于所有情况（并解决了#2 的问题）。更一般地说，这种模式应该像这样使用：

   #define OVERLOADS_OF(name) [&](auto&&... args) -> decltype(name(std::forward<decltype(args)>(args)...)) { return name(std::forward<decltype(args)>(args)...); }
   

   你会通过的：

   OVERLOADS_OF(dummysort)
   

   这对于这种特殊情况来说是多余的，但更普遍有用。

Answer 3

两个次要 cmets：您应该通过引用 std::vector<int> &v 而不是通过值 std::vector<int> v 将 v 参数传递给 benchmark，因为向量是构建起来昂贵的对象。标准流不需要std::endl；而不是

std::cout << "Value of the variable:" << std::endl;
std::cout << variable << std::endl;

你可以写

std::cout << "Value of the variable:\n";
std::cout << variable << '\n';

这既不那么冗长又快得多（这对于这里的琐碎案例并不重要）。

要回答您的问题，不，在这种情况下编译器将无法推断dummysort 的模板参数，因此您必须将其编写为dummysort<std::vector<int>::iterator>。但是有一些方法可以简化它：

1) 如果你的编译器支持 C++14 variable templates 你可以声明

template<typename T>
constexpr auto vecdummysort = dummysort<typename std::vector<T>::iterator>;

然后像这样使用它

benchmark("bubblesort", vecdummysort<int>, first);

2a) 使用 C++11，您可以创建 alias template

template<typename T>
using veciter = typename std::vector<T>::iterator;

这让您可以使用 dummysort 喜欢

benchmark("bubblesort", dummysort<veciter<int>>, first);

2b) 对于与示例 #1 中相同的 vecdummysort 函数：

template<typename T>
void vecdummysort(veciter<T> first, veciter<T> last) {dummysort(first, last);}

3) 您也可以在benchmark 中更改对sort_func 的调用以使用原始指针而不是迭代器，所以

sort_func(v.data(), v.data() + v.size());

而不是

sort_func(v.begin(), v.end());

这意味着您可以使用benchmark 喜欢

benchmark("bubblesort", dummysort<int*>, first);

4) 您可以更改dummysort 的接口以将集合本身​​作为参数而不是迭代器，这会牺牲一点灵活性（例如，如果您只想对集合的一部分进行排序，或者使用反向迭代器，等等）以获得更简洁和更符合人体工程学的界面

template<typename Collection>
void dummysort(Collection &c)
{
    auto first = std::begin(c);
    auto last = std::end(c);
}

用法：

// benchmark()
sort_func(v);
// main()
benchmark("bubblesort", dummysort<std::vector<int>>, first);