Question

我正在尝试初始化自定义矢量对象，但不使用std::initializer_list。我正在做这样的事情：

template <typename T, std::size_t N>
struct vector
{
  template<std::size_t I = 0, typename ...Tp>
  typename std::enable_if<I == sizeof...(Tp), void>::type
  unpack_tuple(std::tuple<Tp...> const& t)
  {
  }

  template<std::size_t I = 0, typename ...Tp>
  typename std::enable_if<I != sizeof...(Tp), void>::type
  unpack_tuple(std::tuple<Tp...> const& t)
  {
    store[I] = std::get<I>(t);

    unpack_tuple<I + 1, Tp...>(t);
  }

  template<typename ...U>
  vector(U&&... args,
    typename std::enable_if<std::is_scalar<U...>::value, void>::type* = 0)
  {
    unpack_tuple(std::forward_as_tuple(std::forward<U>(args)...));
  }

  T store[N];
};

但编译器不会删除构造函数，除非我删除了std::enable_if参数，这是我需要的（因为我不想要非标量参数）。是否存在解决方案？

Answer 1

std::is_scalar<U...>::value

问题在于is_scalar只接受一个类型的参数。您需要编写一个包含多个布尔值的包装器。我也想知道为什么你使用完美转发如果你只想要标量类型 - 只需按值传递它们。这样，当您通过左值时，您也不必担心U被推断为参考。

#include <type_traits>

template<bool B>
using bool_ = std::integral_constant<bool, B>;

template<class Head, class... Tail>
struct all_of
  : bool_<Head::value && all_of<Tail...>::value>{};

template<class Head>
struct all_of<Head> : bool_<Head::value>{};

template<class C, class T = void>
using EnableIf = typename std::enable_if<C::value, T>::type;

// constructor
template<typename... U>
vector(U... args, EnableIf<all_of<std::is_scalar<U>...>>::type* = 0)
{
  unpack_tuple(std::tie(args...)); // tie makes a tuple of references
}

以上代码应该有效。但是，作为建议，如果您不想要某些东西，static_assert您没有得到它，并且不会滥用SFINAE。 :) SFINAE只应在重载的上下文中使用。

// constructor
template<typename... U>
vector(U... args)
{
  static_assert(all_of<std::is_scalar<U>...>::value, "vector only accepts scalar types");
  unpack_tuple(std::tie(args...)); // tie makes a tuple of references
}

您的实际问题非常多，但我建议使用indices trick更好地解包元组（或一般的可变参数，甚至是数组）：

template<unsigned...> struct indices{};
template<unsigned N, unsigned... Is> struct indices_gen : indices_gen<N-1, N-1, Is...>{};
template<unsigned... Is> struct indices_gen<0, Is...> : indices<Is...>{};

template<unsigned... Is, class... U>
void unpack_args(indices<Is...>, U... args){
  [](...){}((store[Is] = args, 0)...);
}

template<class... U>
vector(U... args){
  static_assert(all_of<std::is_scalar<U>...>::value, "vector only accepts scalar types");
  unpack_args(indices_gen<sizeof...(U)>(), args...);
}

这段代码的作用是“滥用”可变参数解包机制。首先，我们生成一组索引[0 .. sizeof...(U)-1]，然后将此列表与args一起展开。我们将此扩展放在一个可变参数（非模板）函数参数列表中，因为包扩展只能在特定位置发生，这就是其中之一。另一种可能性是作为本地数组：

template<unsigned... Is, class... U>
void unpack_args(indices<Is...>, U... args){
  int a[] = {(store[Is] = args, 0)...};
  (void)a; // suppress unused variable warnings
}

std :: initializer_list替代方案

1 个答案: