用实际元素初始化boost :: multi_array的简洁方法

Question

I'm looking for clean syntactic sugar to initialize a boost::multi_array from explicit values. The best I could come up with was

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 }};

boost::multi_array_ref<double,2> mg((double*)g,boost::extents[5][5]);

I don't like this because it requires 2 variables instead of 1, the triply-redundant [5][5] dimensioning (the size can be inferred by the nested curly bracket lists), and the cast from double[][] to double* .

I do like the fact that there isn't a copy performed from g to mg , and the way that g is initialized is pleasing to the eye (ie nested, structured initializer lists with a minimum of superfluous characters).

Answer 1

There are a few options available. All of them require some template magic; they differ in their syntactic expressiveness and efficiency. Life would be easier if boost::multi_array and friends actually provided some more useful constructors, but alas, that is not the case as of this writing.

1) Using a flat initializer_list

This basic option removes some redundancy, and makes for reasonably good syntactic sugar. It uses a helper function that takes an initializer_list<t> , dumps it into an std::vector , and uses that to first create a const_multi_array_ref which is then deep-copied into a 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});

In this version, the appropriate size of the initializer_list is only checked at runtime, but I think in C++14 std::initializer_list::size() is going to be constexpr , which should allow you to use a static_assert .

• Pro: redundancies in the declaration and dimensions are gone.
• Con: creates at least one copy; uses a flat list which is not as readable.

2) Initializing from a C array

This one is closer to your original, but you need to define the array separately – I don't think you can provide it straight as a function parameter with a redundant cast. The advantage is that since you first build a standard C array, you can just re-use that in your multi_array_ref and you do not need a copy. You need some additional constructs in comparison to the first option: CArray is used to construct a C array type from the template parameters.

// 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);

• Pro: keeps the hierarchical structure of your initializer, for better readability; avoids a copy.
• Con: still has some of the redundancy you wanted to get rid of.

3) Using nested initializer_list s

This one seems more proper, but is less efficient. In addition to the code above, we need a way to construct nested initializer_list s, and copy them into an array.

// 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 } });

The last one comes with a little bit of inspiration from this article .

• Pro: the usage is exactly as you wanted it; no redundancies, clear hierarchical initializer structure
• Con: the fillArray() routine is recursive and therefore less efficient (I expect that the compiler won't be able to optimize it as well).