Una linea initialiser per Boost.MultiArray
-
27-10-2019 - |
Domanda
Ho un n-dimensionale Boost.MultiArray inizializzo come segue:
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);
Così ho 4 righe di codice per ottenere il multiarray, ma mi piacerebbe farlo in una sola riga.
C'è un modo semplice per generare un multiarray con n dimensioni ogni lunghezza size
avere (in modo da poter scrivere arr(samevaluearray(n,size))
) o mi sono perso un costruttore a portata di mano per multiarray?
Modifica:. Dovrebbe funzionare senza dipendere da un certo valore di n, cioè arr({{size,size}}
avrebbe funzionato solo per n=2
Poiché non può essere chiaro:. boost::multi_array<char,n>(boost::extents[4][4][4])
inizializza correttamente un 4x4x4-array, ma ogni volta n
è cambiato nel codice sorgente, ogni inizializzazione deve essere aggiornato a mano, quindi non è un'opzione
Soluzione 2
Risulta, std::vector
ha un costruttore, che costruisce un vettore con un valore costante ripetuto n volte, quindi un possibile aspetto soluzione di questo tipo:
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));
Questo inizializza una multi_array n-dimensionale con il set dimensioni di ogni dimensione a misura.
Altri suggerimenti
È possibile incapsulare la creazione della matrice in una funzione di supporto:
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);
Se non è possibile utilizzare auto
, dovrete duplicare i parametri del modello:
boost::multi_array<char, n> arr = make_regular_matrix<char, n>(size);
La funzione make_regular_matrix
potrebbe essere ridotto a usare std::vector
, come avete fatto nella vostra risposta; Non so se questa implementazione sarebbe meglio. Lo scopo della funzione di supporto è quello di nascondere la creazione della matrice, ma altre versioni potrebbe essere scritto, ad esempio per inizializzare gli elementi della matrice con un dato valore:
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
From the Boost Multi-Array documentation, yes, you can initialize it one line:
typedef boost::multi_array<double, 3> array_type;
typedef array_type::index index;
array_type A(boost::extents[3][4][2]);
The typedefs are for readability, one can just as easily do for your example:
boost::multi_array<int, 2> arr(boost::extents[2][4]);