Question

我想使用类型创建模板，以及传递一个包含该类型的模板参数的函数。

以下是我目前的情况：

#include <iostream>

void fooRef(int& ref) { std::cout << "In ref" << std::endl; }
void fooPtr(int* ptr) { std::cout << "In ptr" << std::endl; }

template<typename T, typename F>
void Print(T arg, F func) {
    //DoABunchOfStuff();
    func(arg);
    //DoSomeMoreStuff();
}

int main() {
    int x = 5;
    int& ref = x;

    Print<int*, void(*)(int*)>(&x, &fooPtr);
    Print<int&, void(*)(int&)>(ref, &fooRef);
}

这很有效，但我觉得这个函数的调用者可能会有一些额外的冗长。理想情况下，我希望调用看起来像：

Print<int*, fooPtr>(ptr);
Print<int&, fooRef>(ref);

有没有办法简化对Print功能的调用？

Answer 1

有没有办法简化对Print功能的调用？

是。您所做的并不是指定模板类型。功能模板通过流程调用template argument deduction。在此过程中，传递给函数的参数的类型已推导出来，编译器会尝试将其与模板参数进行匹配。如果它工作，那么函数将被标记出来并且编译器继续。所以，如果我们使用

代码

int main() {
    int x = 5;
    int& ref = x;

    Print(&x, &fooPtr);
    Print(std::ref(ref), &fooRef);
}

然后我们得到

In ptr
In ref

Live Example

在第二次调用中，我使用了std::ref，因此它实际上会通过引用传递ref。否则它会复制ref所指的任何内容。

Answer 2

您可以使用模板参数推导与变量模板混合来简化它。以下是如何做到的：

template<typename FunctionType, typename... ArgumentTypes>
void Print(FunctionType function, ArgumentTypes... args) {
    function(args...);
}

但是，如果要正确支持引用，则必须使用转发引用，这样编译器不仅可以推断出发送的参数的类型，而且还可以推断它。 s值类型。

template<typename F, typename... Args>
void Print(F function, Args&&... args) {
    function(std::forward<Args>(args)...);
}

现在一切似乎都很好，但你仍然需要处理接受任何争论的函数。限制函数只接受使调用有效的参数可以使用尾随返回类型完成：

// instead of specifying the return type before the function name,
// let's place it at the end and use `decltype` to deduce the right type:
template<typename F, typename... Args>
auto Print(F function, Args&&... args) -> decltype(function(std::declval<Args>()...)) {
    return function(std::forward<Args>(args)...);
}

使用此代码，您可以从编译器中获得更清晰的错误：

void func1(int) {}

Print(func1, 1); // works!
Print(func1, 1, 7); // error: no such function to call

如果您仍然希望void作为返回类型并且仍然限制您的功能，那么您可以依赖void_t：

// void_t definition
template<typename...>
using void_t = void;

template<typename F, typename... Args>
auto Print(F function, Args&&... args) -> void_t<decltype(function(std::declval<Args>()...))> {
    function(std::forward<Args>(args)...);
}

Answer 3

是的，您理想的语法很简单：

void fooRef(int& ref) { (void)ref; std::cout << "In ref" << std::endl; }
void fooPtr(int* ptr) { (void)ptr; std::cout << "In ptr" << std::endl; }

template<class T, void(*func)(T)>
void Print(T arg) {
  //DoABunchOfStuff();
  func(std::forward<Arg>(arg));
  //DoSomeMoreStuff();
}

int main() {
  int x = 5;
  int& ref = x;

  Print<int*, fooPtr>(&x);
  Print<int&, fooRef>(ref);
}

Live example

添加了

(void)ref和(void)ptr来抑制未使用的变量警告。 std::forward<T>曾经使一些角落案件更有效率。我还建议用T阻止扣除：

template<class T>struct tag_t{using type=T;};
template<class T>using block_deduction=typename tag_t<T>::type;

template<class T, void(*func)(T)>
void Print(block_deduction<T> arg) {

会强制调用者明确地传递T，因为我认为在这里推导T会使代码变得有点脆弱（它必须与func的签名完全匹配）。

如何将函数传递给模板化函数A，该函数可能具有基于另一个参数A的不同签名？

3 个答案: