如何编写一个函数，该函数采用数组<double，N>的可变数并推导出N？

Question

我们的目标是有一个函数，它可以接收任意数量的任意大小 N 的数组（但这对所有人来说都是一样的），并且在函数体内有 N 可用。例如，假设我想使用 N，MyArray 返回另一个用户定义的数组类型。我希望它更清楚！谢谢我是可变参数模板的新手，不知道该怎么做。任何帮助或提示表示赞赏。谢谢。

#include <array>
using namespace std;

template<int N>
struct MyArray {};

// here I don't know how to deduce N and keep the variadic number of parameters

template<int N, typename... Ts>
MyArray<N> foo(const Ts&... ts)
{ 
  // somehow use the variadic parameters
  MyArray<N> a;
  return a;
}

int main()
{
  array<double, 3> a, b, c;
  auto d = foo(a, b, c);
}

Answer 1

我不完全确定我是否理解你的函数试图做什么。我猜它是“对所有数组求和并在每个字段中添加 N”，如果不是，我的示例应该是一个很好的说明。

template<size_t N, typename... Ts>
std::array<double, N> foo(std::array<double, N> first)
{
  for (size_t i = 0; i < N; ++i) {
    first[i] += N;
  }
  return first;
}

template<size_t N, typename... Ts>
std::array<double, N> foo(const std::array<double, N>& first, Ts&... ts)
{
  std::array<double, N> result = foo(ts...);
  for (size_t i = 0; i < N; ++i) {
    result[i] += first[i];
  }
  return result;
}

template<size_t N>
void print_array(const std::array<double, N>& arr) {
  for (double x : arr) {
    std::cout<<x<<" ";
  }
  std::cout<<"\n";
}

int main() {
  std::array<double, 3> a = {1, 2, 3};
  std::array<double, 3> b = {4, 5, 6};
  std::array<double, 3> c = {7, 8, 9};
  auto d = foo(a, b, c);
  print_array(d);
  d = foo(a, b);
  print_array(d);
}

Answer 2

我想你可以接受std::array的序列，推导出尺寸，SFINAE只有在尺寸一致时才启用该功能。

我的意思是……有点像

template <std::size_t N0, std::size_t ... Ns,
          std::enable_if_t<((N0 == Ns) && ...), int> = 0> 
auto foo (std::array<double, N0> const & a0,
          std::array<double, Ns> const & ... as)
 { 
   std::array<double, N0> d;
   d[0] = (a0[0] + ... + as[0]);
   d[0] += N0;
   return d;
 }

也可以

template <std::size_t ... Ns, std::size_t N = (Ns + ...)/sizeof...(Ns),
          std::enable_if_t<((N == Ns) && ...), int> = 0> 
auto foo (std::array<double, Ns> const & ... as)
 { 
   std::array<double, N> d;
   d[0] = (N + ... + as[0]);
   return d;
 }

或者，如果你愿意，推导出第一个尺寸并强制以下类型相同

template <std::size_t N0, typename ... Ts,
          std::enable_if_t<((std::is_same_v<std::array<double, N0>, Ts>) && ...), int> = 0> 
auto foo (std::array<double, N0> const & a0, Ts const & ... as)
 { 
   std::array<double, N0> d;
   d[0] = (a0[0] + ... + as[0]);
   d[0] += N0;
   return d;
 }

正如 François Andrieux 所指出的，您可以采用 static_assert() 方式而不是 SFINAE 方式，以获得更有意义的消息错误

template <std::size_t N0, std::size_t ... Ns> 
auto foo (std::array<double, N0> const & a0,
          std::array<double, Ns> const & ... as)
 { 
   static_assert( ((N0 == Ns) && ...), "some clear error message!");

   // ...

但是，通过这种方式，您无法开发不同的替代版本的foo()。

看看什么解决方案对你更有用。

Answer 3

我终于设法做到了，仍然不好的元素是 Foo 模板部分中 N 的类型必须与 std::array 中使用的类型完全匹配以指示大小，这使得 N 在内部已知并且可以用于制作 MyArray 对象。

基本上我必须将参数包声明为模板（因此有一个带有模板包的模板）。 Ts... 是因为数组通常需要超过 2 个模板参数。

#include <array>
using namespace std;

template<int N>
struct MyArray {};

template<typename T, long unsigned N, typename... Ts, template<typename, long unsigned, typename...> typename... Arrays>
MyArray<N> Foo(const Arrays<T, N, Ts...>&... arrays)
{
    return MyArray<N>{};
}

int main()
{
    array<double, 3> a, b, c;

    MyArray<3> d = Foo(a, b, c);
    auto e = Foo(a, b);

    return 0;
}