有几个可用的选项。所有这些都需要一些模板魔法;它们在语法表达和效率上有所不同。如果boost::multi_array和朋友们实际上提供了一些更有用的构造函数，生活会更容易，但遗憾的是，截至本文撰写时，情况并非如此。

1）使用扁平initializer_list

这个基本选项消除了一些冗余，并使语法糖相当好。它使用一个helper函数，该函数接受initializer_list<t>，将其转储到std::vector中，并使用该函数首先创建const_multi_array_ref，然后将其深度复制到multi-array中。

#include <boost/multi_array.hpp>
#include <cassert>
#include <initializer_list>
#include <vector>
// Helper class to determine the full number of elements in the
// multi-dimensional array
template <std::size_t... vs> struct ArraySize;
template <std::size_t v, std::size_t... vs> struct ArraySize<v, vs...>
{ static constexpr std::size_t size = v * ArraySize<vs...>::size; };
template <> struct ArraySize<>
{ static constexpr std::size_t size = 1; };
// Creates your multi_array
template <typename T, int... dims>
boost::multi_array<T, sizeof...(dims)>
makeMultiArray(std::initializer_list<T> l)
{
  constexpr std::size_t asize = ArraySize<dims...>::size;
  assert(l.size() == asize); // could be a static assert in C++14
  // Dump data into a vector (because it has the right kind of ctor)
  const std::vector<T> a(l);
  // This can be used in a multi_array_ref ctor.
  boost::const_multi_array_ref<T, sizeof...(dims)> mar(
    &a[0],
    std::array<int, sizeof...(dims)>{dims...});
  // Finally, deep-copy it into the structure we can return.
  return boost::multi_array<T, sizeof...(dims)>(mar);
}
// Usage example
auto mg = makeMultiArray<double, 5, 5>({
  -0.0009, 0.003799, 0.00666, 0.00374, 0.00186,
  -0.0008, 0.0176,   0.0619,  0.0159,  0.00324,
  0.00099, 0.0475,   0.666,   0.0376,  0.00758,
  0.00242, 0.02189,  0.0624,  0.0192,  0.0008,
  0.00182, 0.00404,  0.00479, 0.00924, 0.00189});

字符串
在这个版本中，initializer_list的适当大小只在运行时检查，但我认为在C++14中std::initializer_list::size()将是constexpr，这应该允许您使用static_assert。

• 优点：声明和维度中的冗余消失了。
• 缺点：至少创建一个副本;使用一个不那么可读的平面列表。

2）从C数组初始化

这一个更接近于你的原始数组，但是你需要单独定义数组-我不认为你可以直接将它作为一个函数参数提供给一个冗余的类型转换。优点是因为你首先构建了一个标准的C数组，你可以在你的multi_array_ref中重用它，而不需要复制。与第一个选项相比，你需要一些额外的构造：CArray用于从模板参数构造C数组类型。

// CArray<double,1,2,3>::type is double[1][2][3]
template <typename T, std::size_t... vs> struct CArray;
template <typename T, std::size_t v, std::size_t... vs> struct CArray<T, v, vs...>
{ typedef typename CArray<T, vs...>::type type[v]; };
template <typename T> struct CArray<T> { typedef T type; };
// Creates a multi_array_ref
template <typename T, int... dims>
boost::multi_array_ref<T, sizeof...(dims)>
makeMultiArray(typename CArray<T, dims...>::type l)
{
  constexpr std::size_t asize = ArraySize<dims...>::size;
  return boost::multi_array_ref<T, sizeof...(dims)>(
           reinterpret_cast<double*>(l),
           std::array<int, sizeof...(dims)>{dims...});
}
// Usage example
double g[5][5] =
  { { -0.0009, 0.003799, 0.00666, 0.00374, 0.00186 },
    { -0.0008, 0.0176,   0.0619,  0.0159,  0.00324 },
    { 0.00099, 0.0475,   0.666,   0.0376,  0.00758 },
    { 0.00242, 0.02189,  0.0624,  0.0192,  0.0008  },
    { 0.00182, 0.00404,  0.00479, 0.00924, 0.00189 } };
auto mg = makeMultiArray<double, 5, 5>(g);

型

• 优点：保持初始化器的层次结构，以提高可读性;避免复制。
• 缺点：仍然有一些你想摆脱的冗余。

3）使用嵌套initializer_list s

除了上面的代码，我们还需要一种方法来构造嵌套的initializer_list s，并将它们复制到一个数组中。

// Nested initializer lists
template <typename T, std::size_t level> struct NestedInitializerList
{
  typedef std::initializer_list<typename NestedInitializerList<T, level-1>::type> type;
};
template <typename T> struct NestedInitializerList<T, 1>
{
  typedef std::initializer_list<T> type;
};
// Helpers which fill the array from a nested initializer_list
template <typename T>
void fillArray(const T& l, typename CArray<T>::type& a)
{
  a = l;
}
template <typename T, int dim, int... dims>
void fillArray(typename NestedInitializerList<T, sizeof...(dims)+1>::type l,
               typename CArray<T, dim, dims...>::type& a)
{
  assert(l.size() == dim); // could be a static assert in C++14
  int i=0;
  for (auto it = l.begin(); it != l.end(); ++it, ++i)
  {
    fillArray<T, dims...>(*it, a[i]);
  }
}
// Creates your multi_array
template <typename T, int... dims>
boost::multi_array<T, sizeof...(dims)>
makeMultiArray(typename NestedInitializerList<T, sizeof...(dims)>::type l)
{
  typename CArray<T, dims...>::type a; // Multidimensional C array
  fillArray<T, dims...>(l, a);         // Fill from l
  // Turn into multi_array_ref.
  boost::const_multi_array_ref<T, sizeof...(dims)> mar(
    reinterpret_cast<const double*>(a),
    std::array<int, sizeof...(dims)>{dims...});
  // Finally, deep-copy it into the structure we can return.
  return boost::multi_array<T, sizeof...(dims)>(mar);
}
// Usage example
auto mg = makeMultiArray<double, 5, 5>(
  { { -0.0009, 0.003799, 0.00666, 0.00374, 0.00186 },
    { -0.0008, 0.0176,   0.0619,  0.0159,  0.00324 },
    { 0.00099, 0.0475,   0.666,   0.0376,  0.00758 },
    { 0.00242, 0.02189,  0.0624,  0.0192,  0.0008  },
    { 0.00182, 0.00404,  0.00479, 0.00924, 0.00189 } });

型
最后一个来自this article的一点灵感。

• 优点：用法完全符合您的要求;没有冗余，清晰的分层初始化器结构
• 缺点：fillArray()例程是递归的，因此效率较低（我预计编译器也无法优化它）。