Question

假设我有一个模板类

template <typename T> class foo;
template <typename... Args>
struct foo<std::tuple<Args...>> {
  std::tuple<Args...> t;
  foo(Args&&... args): t{std::forward<Args>(args)...} { }
};

我理解在这种情况下，Args&&...是右值引用，我可以写得std::move而不是std::forward。

我也可以有一个带左值引用的构造函数，如此

foo(const Args&... args): t{args...} { }

问题是，是否可以获得与转发引用相同的行为，但是对于确定类型？我想要这个的原因是我可以使用像

这样的语法

foo bar({. . .}, {. . .}, . . ., {. . .});

如果我定义foo(Args&&... args)构造函数，但不允许混合场景，我想用支持封闭的初始化列表初始化一些成员元组元素，并从原有对象复制其他元素，这是有效的实例

Answer 1

不确定;有一种奇特而简单的方式。

我将在下面详述的奇特方式。首先是简单的方法：按价值收取。

template <typename... Args>
struct foo<std::tuple<Args...>> {
  std::tuple<Args...> t;
  foo(Args... args): t{std::forward<Args>(args)...} { }
};

真的，就这样做吧。如果Args包含引用，则转发用于执行正确的操作。

按值计算会增加完美转发的一个举措，但会以指数方式减少对重载的要求。

这是一种奇特的方式。我们键入擦除构造：

template<class T>
struct make_it {
  using maker=T(*)(void*);
  maker f;
  void* args;
  // make from move
  make_it( T&& t ):
    f([](void* pvoid)->T{
      return std::move(*static_cast<T*>(pvoid));
    }),
    args(std::addressof(t))
  {}
  // make from copy
  make_it( T const& t ):
    f([](void* pvoid)->T{
      return *(T const*)(pvoid);
    }),
    args(std::addressof(t))
  {}
  operator T()&&{return std::move(*this)();}
  T operator()()&&{ return f(args); }
};

此类型通过复制或移动来删除构造。

template <typename... Args>
struct foo<std::tuple<Args...>> {
  std::tuple<Args...> t;
  foo(make_it<Args>... args): t{std::move(args)()...} { }
};

它并不完全透明，但它尽可能接近。

需要双{{}}而不是单身。它是用户定义的转换，因此不会隐式地执行另一个转换。我们可以添加一个通用的ctor：'

  // make from universal
  template<class U>
  make_it( U&& u ):
    f([](void* pvoid)->T{
      return std::forward<U>(*(U*)(pvoid));
    }),
    args(std::addressof(u))
  {}

如果我们添加一个U&&可用于隐式构建T的sfinae奶嘴，效果会更好。

它有一些优势，但它们只是靠价值而略有优势。例如，在C ++ 17中，在某些情况下，非可移动类型可以完美地构造。

转发具有确定类型的引用行为

1 个答案: