initialiseur une ligne pour Boost.MultiArray

Question

I ai n dimensions Boost.MultiArray I initialize comme suit:

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

J'ai donc 4 lignes de code pour obtenir le multiarray, mais je voudrais le faire en une seule ligne. Est-il un moyen simple de générer un multiarray avec n dimensions chacun ayant une longueur de size (donc je peux écrire arr(samevaluearray(n,size))) ou ne me manque un constructeur pratique pour multiarray?

Modifier. Il devrait fonctionner sans dépendre d'une certaine valeur de n, à savoir arr({{size,size}} ne fonctionne que pour n=2

Comme il ne peut pas être clair. boost::multi_array<char,n>(boost::extents[4][4][4]) correctement un 4x4x4 initialise-tableau, mais chaque n temps est changé dans le code source, chaque initialisation doit être mis à jour à la main, il est donc pas une option

Answer 1

Tours dehors, std::vector a un constructeur, qui construit un vecteur ayant une valeur constante répété n fois, de sorte qu'une allure de solution possibles comme ceci:

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

initialise un n-dimensionnelle multi_array avec le jeu de taille de la taille de chaque dimension.

Answer 2

Vous pouvez encapsuler la création du tableau dans une fonction d'aide:

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

Si vous ne pouvez pas utiliser auto, vous devrez dupliquer les paramètres du modèle:

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

La fonction make_regular_matrix pourrait être raccourci à utiliser std::vector, comme vous l'avez fait dans votre réponse; Je ne sais pas si cette mise en œuvre serait mieux. Le but de la fonction d'aide est de cacher la création du tableau, mais d'autres versions pourraient être écrit, par exemple pour initialiser les éléments du tableau avec une valeur donnée:

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

Answer 3

De la Boost documentation multi-Array , oui, vous pouvez initialiser une ligne:

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

Les typedefs sont pour une meilleure lisibilité, on peut tout aussi bien faire pour votre exemple:

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