Jedna linia initialiser dla Boost.MultiArray

Question

mam n-wymiarowej Boost.MultiArray zainicjować w następujący sposób:

const int n=3, size=4; //# of dimensions and size of one dimension 
boost::multi_array<char,n> arr; 
boost::array<size_t,n> extents; //size of each dimension 
extents.assign(size); //assign size to each dimension -> {{4, 4, 4}} 
arr.resize(extents); 

Więc mam 4 linie kodu, aby uzyskać MultiArray, ale chciałbym zrób to w jednym wierszu. Czy istnieje prosty sposób na wygenerowanie MultiArray o n wymiarach, każdy o długości size (czy mogę napisać arr(samevaluearray(n,size))) lub czy brakuje mi przydatnego konstruktora dla MultiArray?

Edit: To powinno działać bez zależności od pewnej wartości n, tj arr({{size,size}} będzie działać tylko dla n=2.

Ponieważ nie może być jasne: boost::multi_array<char,n>(boost::extents[4][4][4]) poprawnie inicjuje 4x4x4-tablicę, ale za każdym razem n zmienia się w kod źródłowy, każdy inicjalizacji musi być aktualizowana ręcznie, więc nie jest to opcja.

Answer 1

Okazuje się, std::vector ma konstruktora, który konstruuje wektor o stałej wartości powtarzanej n razy, więc możliwe rozwiązanie wygląda następująco:

const int n=2, size=4; //# of dimensions and size of one dimension 
boost::multi_array<char,n> arr(std::vector<size_t>(n,size)); 

Powoduje zainicjowanie n-wymiarowej multi_array z wielkością każdego wymiaru ustawioną na rozmiar.

Answer 2

Z Boost Multi-Array documentation, tak, można zainicjować jedną linię:

typedef boost::multi_array<double, 3> array_type; 
typedef array_type::index index; 
array_type A(boost::extents[3][4][2]); 

W typedefs są dla czytelności, można równie dobrze zrobić dla przykładu:

boost::multi_array<int, 2> arr(boost::extents[2][4]); 

Answer 3

można upakować tworzenie tablicy do funkcji pomocniczych:

template <typename T, size_t N> 
boost::multi_array<T, N> make_regular_matrix(const size_t m) 
{ 
    boost::multi_array<T, N> arr; 
    boost::array<size_t, N> extents; 
    extents.assign(m); 
    arr.resize(extents); 

    return arr; 
} 

const int n = 3; 
int size = 4; // Can be const as well, but this is not mandatory 

auto arr = make_regular_matrix<char, n>(size); 

Jeśli nie można używać auto, musisz powielać parametry szablonu:

boost::multi_array<char, n> arr = make_regular_matrix<char, n>(size); 

make_regular_matrix funkcja może być skrócony do użycia std::vector, tak jak w twojej odpowiedzi; Nie wiem, czy ta implementacja byłaby lepsza. Celem funkcji pomocnika jest ukrycie tworzenie tablicy, ale inne wersje mogą być napisane, na przykład zainicjować elementów tablicy z danej wartości:

template <size_t N, typename T> //switched order for deduction 
boost::multi_array<T, N> make_regular_matrix(const size_t m, const T & value) 
{ 
    boost::multi_array<T, N> arr(std::vector<size_t>(n, m)); 

    std::fill(arr.data(), arr.data() + arr.num_elements(), value); 

    return arr; 
} 

auto arr = make_regular_matrix<4>(3, 'z'); //creates a 3x3x3x3 matrix 
              //filled with 'z's