【问题标题】:How can I construct std::tuple of references from a parameter pack?如何从参数包构造 std::tuple 引用?
【发布时间】:2019-09-13 16:54:22
【问题描述】:

我有一个构建器类,我想将参数存储为引用以供后续构建使用。

我想将可变数量的参数传递给我的类,使用类模板参数推导推断模板参数,并将这些传递的参数作为引用存储在 std::tuple 中。

从参数包转换为 std::tuple 引用的最简单方法是什么?

我发现 std::forward_as_tuple 的功能与我想要的类似,但我不想要转发引用,而且它在成员元组初始化期间会出现语法错误。

template <typename... Ts>
struct Builder
{
using ArgsT = decltype(std::forward_as_tuple(Ts{}...));

ArgsT args_;

Builder(Ts&... ts) : args_(ts...) {}
};

int main()
{
    struct Foo
    {
        int a;
        double b;
    };

    Foo foo{};
    Builder fooBuilder{foo.a, foo.b};
}

语法错误是:

错误:没有匹配函数调用std::tuple&lt;int&amp;&amp;, double&amp;&amp;&gt;::tuple(int&amp;, double&amp;)

【问题讨论】:

  • 你能说明一下你打算如何在初始化后使用Builder吗?
  • 为了这个问题,我简化了 Builder。实际上,它会采用另一个模板类,并在实际的构建方法中接收参数。

标签: c++ c++17 variadic-templates stdtuple


【解决方案1】:

如果你只是想参考,直接使用:

template <typename... Ts>
struct Builder
{
    using ArgsT = std::tuple<Ts&...>;

    ArgsT args_;

    Builder(Ts&... ts) : args_(ts...) {}
};

int main()
{
    struct Foo
    {
        int a;
        double b;
    };

    Foo foo{};
    Builder fooBuilder{foo.a, foo.b};
}

对于您的代码:

decltype(std::forward_as_tuple(Ts{}...)) 解析为 std::tuple&lt;Ts&amp;&amp;...&gt;。
Ts{} 创建一个临时的(并要求您的类型是默认可构造的)。

你不能将int&amp;绑定到int&amp;&amp;。

您可以使用decltype(std::forward_as_tuple(std::declval&lt;Ts&amp;&gt;()...)),它在std::tuple&lt;Ts&amp;...&gt; 中解析,但后来更简单并提供了解决方案;-)。

【讨论】:

    【解决方案2】:

    另一种方式:

    #include <tuple>
    
    template<typename Tuple>                                                                                                    
    struct Builder                                                                                                      
    {                                                                                                                            
        Tuple args_;                                                                                            
        Builder(Tuple const& t) : args_(t) {}                                                                    
    };
    
    int main()                                                                                                                   
    {                                                                                                                            
        struct Foo                                                                                                               
        {                                                                                                                        
            int a;                                                                                                               
            double b;                                                                                                            
        };                                                                                                                       
    
        Foo foo{};                                                                                                               
        Builder fooBuilder{std::tie(foo.a, foo.b)};                                                                               
    }   
    

    【讨论】:

      【解决方案3】:

      Builder(Ts&amp;... ts) 是一组左值引用。

      Ts{}... 是一组相同类型的纯右值。

      std::forward_as_tuple(Ts{}...) 是一个包含对同一类型的右值引用的元组。

      左值引用和右值引用不是一回事;您不能将一个分配给另一个。所以args_(ts...) 会生成相应的错误消息。

      有不止一种方法可以解决您的问题。

      template <typename... Ts>
      struct Builder
      {
        using ArgsT = std::tuple<Ts&&...>; // (1)
        using ArgsT = std::tuple<Ts&...>;  // (2)
        using ArgsT = std::tuple<Ts...>;   // (3)
      

      这三种方法实际上都是解决问题的合理方法,具体取决于后面的代码选项。根据您的真正问题选择一个。

        ArgsT args_;
      

      这里发生了什么:

        Builder(Ts&&... ts) : args_(std::forward<Ts>(ts)...) {}
        Builder(Ts&... ts) : args_(ts...) {}
        Builder(Ts&&... ts) : args_(std::forward<Ts>(ts)...) {}
      

      针对上述 3 种情况。

      在情况 (1) 中,您将参数完美地转发到一个元组中,并且该元组存储对任何右值参数的右值引用。在情况(2)中,您只采用左值参数,并且存储了一个对它们的左值引用元组。在情况 (3) 中,您将参数完美地转发到一个元组中,如果参数是一个右值并且左值引用它,则存储值,他的值是一个左值。

      (3) 当您希望引用比当前行更有效时很有用;唯一安全的方法是存储一个副本,然后移入其中。

      如果您只想引用左值,

      (2) 很有用。

      (1) 如果您的 Builder 对象不会超过当前行,并且您不想为移动的对象付费,则很有用。它比(1)更危险。

      所有 3 个都将使您的示例代码编译。

      【讨论】:

        猜你喜欢
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        • 2019-07-06
        • 2021-04-09
        • 2020-04-07
        • 2016-11-11
        • 2012-12-11
        • 1970-01-01
        相关资源
        最近更新 更多