如何将右值引用参数传递给 C++ 中的模板运算符（） function？

Question

我试图编写一些代码来在 C++17 中实现一个咖喱 function。 我的当前实现在下面（我将在这个问题的底部给你一个最小的工作示例）。

template <class Function, class... CapturedArgs>
class curried{
private:
    using CapturedArgsTuple = std::tuple<std::decay_t<CapturedArgs>...>;
    template <class... Args>
    static auto capture_by_value(Args&&... args){
        return std::tuple<std::decay_t<Args>...>(std::forward<Args>(args)...);
    }
public:
    curried(Function function, CapturedArgs&&... args)
        : m_function(function), m_capture(capture_by_value(std::move(args)...)){}

    curried(Function function, std::tuple<CapturedArgs...> args)
        : m_function(function), m_capture(std::move(args)){}

    template <class... NewArgs>
    auto operator()(NewArgs&&... args){
        auto new_args = capture_by_value(std::forward<NewArgs>(args)...);
        auto all_args = std::tuple_cat(m_capture, new_args);
        if constexpr(std::is_invocable_v<Function, CapturedArgs..., NewArgs...>){
            return std::apply(m_function, all_args);
        }else{
            return curried<Function, CapturedArgs..., NewArgs...>(m_function, all_args);
        }
    }
private:
    Function m_function;
    std::tuple<CapturedArgs...> m_capture;
};

这是一个测试 function：

void func(const string& str1, string& str2, string str3){
    str2 += "str2 ";
    cout << "str1 = " << str1 
         << ", str2 = " << str2 
         << ", str3 = " << str3 << endl;
}
int main(){
    string str1 = "Hello ", str2 = "World", str3 = "!";
    auto test = curried(func);
    auto test_two = test(std::cref(str1))(std::ref(str2));
    cout << "result : ";
    test_two(str3);
}

到目前为止，一切都很好。 我可以在终端上看到一些日志打印，例如：

$ result : str1 = Hello , str2 = Worldstr2 , str3 = !

我在这里有两个问题：

第一个是如何通过传递右值引用来调用 curried function？ 我已经尝试了所有可以搜索的内容，但结果要么是编译错误，要么什么都没有。

void func_1(const string& str1, string& str2, string&& str3){
    str2 += "str2 ";
    cout << "str1 = " << str1 
         << ", str2 = " << str2 
         << ", str3 = " << str3 << endl;
}
int main(){
    string str1 = "Hello ", str2 = "World", str3 = "!";
    auto test = curried(func_1);
    auto test_two = test(std::cref(str1))(std::ref(str2));
    cout << "result : ";
    // test_two(std::move(str3)); Compile Error
    // test_two(string("!"));     Compile Error
    test_two(std::bind(std::move<string&>, str3));  // Compile successfully, but there's nothing output
}

在解决第一个问题的过程中，我发现了一些奇怪的东西。 这是一个例子：

void func_2(const string& str1, string& str2, string str3, string& str4){
    str2 += "str2 ";
    cout << "str1 = " << str1 
         << ", str2 = " << str2 
         << ", str3 = " << str3 
         << ", str4 = " << str4 << endl;
}
int main(){
    string str1 = "Hello ", str2 = "World", str3 = "!", str4 = "abc";
    auto test = curried(func_2);
    auto test_two = test(std::cref(str1))(std::ref(str2))(str3);
    cout << "result : ";
    test_two(std::ref(str4)); 
}

当我使用 func_2 测试我的咖喱 function 时，我收到了一些错误消息：

$ g++ curried.cc -std=c++17
curried.cc: In instantiation of ‘auto curried<Function, CapturedArgs>::operator()(NewArgs&& ...) [with NewArgs = {std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&}; Function = void (*)(const std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>, std::__cxx11::basic_string<char>&); CapturedArgs = {std::reference_wrapper<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >}]’:
curried.cc:60:15:   required from here
curried.cc:28:11: error: no matching function for call to ‘curried<void (*)(const std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>, std::__cxx11::basic_string<char>&), std::reference_wrapper<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&>::curried(void (*&)(const std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>, std::__cxx11::basic_string<char>&), std::tuple<std::reference_wrapper<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)’
   28 |    return curried<Function, CapturedArgs..., NewArgs...>(m_function, all_args);
      |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
curried.cc:18:2: note: candidate: ‘curried<Function, CapturedArgs>::curried(Function, std::tuple<_Elements ...>) [with Function = void (*)(const std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>, std::__cxx11::basic_string<char>&); CapturedArgs = {std::reference_wrapper<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&}]’
   18 |  curried(Function function, std::tuple<CapturedArgs...> args)
      |  ^~~~~~~
curried.cc:18:57: note:   no known conversion for argument 2 from ‘tuple<std::reference_wrapper<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >>’ to ‘tuple<std::reference_wrapper<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&>’
   18 |  curried(Function function, std::tuple<CapturedArgs...> args)
      |                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
curried.cc:15:2: note: candidate: ‘curried<Function, CapturedArgs>::curried(Function, CapturedArgs&& ...) [with Function = void (*)(const std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>, std::__cxx11::basic_string<char>&); CapturedArgs = {std::reference_wrapper<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&}]’
   15 |  curried(Function function, CapturedArgs&&... args)
      |  ^~~~~~~
curried.cc:15:2: note:   candidate expects 4 arguments, 2 provided
curried.cc:7:7: note: candidate: ‘constexpr curried<void (*)(const std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>, std::__cxx11::basic_string<char>&), std::reference_wrapper<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&>::curried(const curried<void (*)(const std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>, std::__cxx11::basic_string<char>&), std::reference_wrapper<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&>&)’
    7 | class curried{
      |       ^~~~~~~
curried.cc:7:7: note:   candidate expects 1 argument, 2 provided
curried.cc:7:7: note: candidate: ‘constexpr curried<void (*)(const std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>, std::__cxx11::basic_string<char>&), std::reference_wrapper<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&>::curried(curried<void (*)(const std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>&, std::__cxx11::basic_string<char>, std::__cxx11::basic_string<char>&), std::reference_wrapper<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::reference_wrapper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&>&&)’
curried.cc:7:7: note:   candidate expects 1 argument, 2 provided
curried.cc: In function ‘int main()’:
curried.cc:60:10: error: void value not ignored as it ought to be
   60 |  test_two(str3)(std::ref(str4));
      |  ~~~~~~~~^~~~~~

所以第二个问题是为什么我不能把字符串参数str3放在字符串引用一个str4之前？ 为什么参数定义的顺序很重要让我完全不知所措。

---

为了您的方便，这里是一个最小的工作示例：

#include <iostream>
#include <functional>
#include <tuple>
using namespace std;

template <class Function, class... CapturedArgs>
class curried{
private:
    using CapturedArgsTuple = std::tuple<std::decay_t<CapturedArgs>...>;
    template <class... Args>
    static auto capture_by_value(Args&&... args){
        return std::tuple<std::decay_t<Args>...>(std::forward<Args>(args)...);
    }
public:
    curried(Function function, CapturedArgs&&... args)
        : m_function(function), m_capture(capture_by_value(std::move(args)...)){}

    curried(Function function, std::tuple<CapturedArgs...> args)
        : m_function(function), m_capture(std::move(args)){}

    template <class... NewArgs>
    auto operator()(NewArgs&&... args){
        auto new_args = std::make_tuple(std::forward<NewArgs>(args)...);
        auto all_args = std::tuple_cat(m_capture, std::move(new_args));
        if constexpr(std::is_invocable_v<Function, CapturedArgs..., NewArgs...>){
            return std::apply(m_function, all_args);
        }else{
            return curried<Function, CapturedArgs..., NewArgs...>(m_function, all_args);
        }
    }
private:
    Function m_function;
    std::tuple<CapturedArgs...> m_capture;
};

void func_1(const string& str1, string& str2, string&& str3){
    str2 += "str2 ";
    cout << "str1 = " << str1 
         << ", str2 = " << str2 
         << ", str3 = " << str3 << endl;
}

void func_2(const string& str1, string& str2, string str3, string& str4){
    str2 += "str2 ";
    cout << "str1 = " << str1 
         << ", str2 = " << str2 
         << ", str3 = " << str3 
         << ", str4 = " << str4 << endl;
}

int main()
{
    /* code */
    string str1 = "Hello ", str2 = "World", str3_for_func_1 = "!", 
           str3_for_func_2 = "!", str4 = "abc";
    auto question_1 = curried(func_1);  // For the first question
    auto question_2 = curried(func_2);  // For the second question
    auto question_1_two_params = question_1(std::cref(str1))(std::ref(str2));
    auto question_2_two_params = question_2(std::cref(str1))(std::ref(str2));   
    cout << "result : ";
    //question_1_two_params(std::move(str3_for_func_1));  // Compile Error  
    //question_1_two_params(string("abc"));  // Compile Error   
    //auto question_2_three_params = question_2_two_params(str3_for_func_2);  // Compile Error
    //question_2_three_params(std::ref(str4)); // It should output some log like "result : str1 = Hello, balabala..."
    return 0;
}

编译命令：

$ g++ curryied.cc -std=c++17 -o curried 

我的工作环境是：

操作系统：Ubuntu-20.04 编译器：gcc 版本 9.3.0

Answer 1

问题 1

一个问题在于std::apply(m_function, all_args); 您将all_args作为左值传递给std::apply ，这会将其作为左值传递给func_1的第三个参数，这将失败，因为func_1的第三个参数是一个右值引用，它不能绑定到左值参数。

实际上，将该行更改为std::apply(m_function, std::move(all_args)); 使前两个// Compile Error行实际编译并生成正确的 output。 同样，我也会在all_args的其他用法上调用std::move 。

问题 2

它看起来像std::make_tuple(std::forward<NewArgs>(args)...); 没有做你认为它做的事情。 将其更改为std::tuple<NewArgs&&...>(std::forward<NewArgs>(args)...); 解决问题； 相当于std::forward_as_tuple(std::forward<NewArgs>(args)...); .

为何此更改起作用的细节在于std::make_tuple与std::forward_as_tuple的返回类型：后者返回引用元组，而前者返回已从 arguments 复制/移动的值元组。

现在，按照我的推理：

• 首先，看看curried(Function function, std::tuple<CapturedArgs...> args) ：它需要参数args应该是std::tuple<CaptureArgs...>类型。 我们确定args有那种类型吗？ 好吧，如果发生模板类型推导，那么答案显然是肯定的。 但是，对该构造函数的调用永远不会利用类型推导，因为唯一的调用是return curried<Function, CapturedArgs..., NewArgs...>(m_function, all_args); 其中明确提供了模板 arguments。
• 所以问题仍然存在： all_args是构造函数期望的类型吗？ 嗯，递归调用中的模板arguments CapturedArgs..., NewArgs...对应的是class... CapturedArgs模板参数class的模板参数，用来形成参数的构造函数的类型std::tuple<CaptureArgs...> 。
• 所以这个问题的答案由static_assert给出，在递归return之前， all_args的类型是std::tuple<CapturedArgs..., NewArgs...> ：

   static_assert(std::is_same_v<decltype(all_args), std::tuple<CapturedArgs..., NewArgs...>>); return curried<Function, CapturedArgs..., NewArgs...>(m_function, all_args);

• 不幸的是，您不能将此断言放入代码中，只要您传递包装在std::ref / std::cref中的值，因为这些值无法通过static_assert离子但仍然是有效输入，这正是因为std::reference_wrapper的工作。 您可以编写更复杂的断言，或者您可以暂时将std::ref(bla)更改为bla等等，并检查我给您的static_assert在使用std::forward_as_tuple时是否通过，在使用std::make_tuple时是否失败。

感谢您提出这个问题。 这对我来说是一个很好的机会，可以再次深入这个复杂的话题并最终理解它！

还有一点

上面我建议你使用std::forward_as_tuple(std::forward<NewArgs>(args)...); .

好吧，可能这个建议是错误的。

在第 238 页，作者明确指出他希望元组存储副本，以防止柯里化的 function 在其 arguments 中幸存的情况。 因此，最好用这个代替 go （注意，传递给std::tuple的模板参数中没有&& ）：

        auto new_args = std::tuple<NewArgs...>(std::forward<NewArgs>(args)...);