Impostare il puntatore sull’array di dimensioni arbitrarie?

Quando voglio iniziare un array multidimensionale, di solito uso solo i puntatori. Ad esempio, per due dimensioni uso:

double **array 

e per tre io uso:

 double ***array 

Tuttavia, mi piacerebbe impostare un array multidimensionale basato su un argomento della riga di comando che indica la dimensione. C’è un modo per impostare una serie di dimensioni arbitrarie una volta che hai una variabile con il numero di dimensioni che desideri?

Anche se questa intera domanda è un’indicazione di un difetto di progettazione, è ansible (in qualche modo ) realizzare questo:

 template class MultiArray { public: MultiArray(std::size_t dimen, std::size_t dimen_size) : _dimensions(dimen) { _data = new T[dimen * dimen_size]; } // implment copy constructor, copy-assignment operator, destructor, and move constructors as well T* operator[](int i) { assert(0 <= i && i < _dimensions); // bounds check for your dimension return &_data[i]; } private: T* _data; std::size_t _dimensions; }; int main() { MultiArray a(5, 2); a[4][1] = 3; std::cout << a[4][1] << std::endl; return 0; } 

Se lo vuoi frastagliato, dovresti fare più matematica e manutenzione per quanto riguarda i limiti di ciascuna "dimensione".

Il problema che stai incontrando ha fatto sì che le dimensioni significassero qualcosa per la tua applicazione. In genere, una matrice multidimensionale rappresenta qualcosa (ad esempio, un vettore 2D può rappresentare lo spazio cartesiano, un vettore 3D o 4D può essere utilizzato per manipolare i dati per la grafica 3D). Oltre la quarta dimensione, trovare un significato valido per l'array diventa torbido e mantenere la logica alla base diventa sempre più complesso con ogni nuova dimensione.

potresti essere interessato al seguente codice che ti consente di utilizzare qualsiasi dimensione “dynamic”:

 #include  #include  #include  template class MultiArray { public: explicit MultiArray(const std::vector& dimensions) : dimensions(dimensions), values(computeTotalSize(dimensions)) { assert(!dimensions.empty()); assert(!values.empty()); } const T& get(const std::vector& indexes) const { return values[computeIndex(indexes)]; } T& get(const std::vector& indexes) { return values[computeIndex(indexes)]; } size_t computeIndex(const std::vector& indexes) const { assert(indexes.size() == dimensions.size()); size_t index = 0; size_t mul = 1; for (size_t i = 0; i != dimensions.size(); ++i) { assert(indexes[i] < dimensions[i]); index += indexes[i] * mul; mul *= dimensions[i]; } assert(index < values.size()); return index; } std::vector computeIndexes(size_t index) const { assert(index < values.size()); std::vector res(dimensions.size()); size_t mul = values.size(); for (size_t i = dimensions.size(); i != 0; --i) { mul /= dimensions[i - 1]; res[i - 1] = index / mul; assert(res[i - 1] < dimensions[i - 1]); index -= res[i - 1] * mul; } return res; } private: size_t computeTotalSize(const std::vector& dimensions) const { size_t totalSize = 1; for (auto i : dimensions) { totalSize *= i; } return totalSize; } private: std::vector dimensions; std::vector values; }; int main() { MultiArray m({3, 2, 4}); m.get({0, 0, 3}) = 42; m.get({2, 1, 3}) = 42; for (size_t i = 0; i != 24; ++i) { assert(m.computeIndex(m.computeIndexes(i)) == i); } return 0; }