dynamisches zweidimensionales Array nach Eingabe

Ich brauche eine Eingabe N vom Benutzer und erzeuge eine N * N-Matrix. Wie kann ich die Matrix deklarieren? Im Allgemeinen sollte die Größe des Arrays und der Matrix bei der Deklaration festgelegt werden, richtig? Was ist mit vector<vector> ? Ich benutze das nie zuvor, also brauche ich einen Vorschlag von Veteran.

Boost implementiert Matrizen (die mathematische Operationen unterstützen) in seiner uBLAS-Bibliothek und stellt eine Syntax wie die folgende bereit.

 #include  int main(int argc, char* argv[]) { unsigned int N = atoi(argv[1]); boost::matrix myMatrix(N, N); for (unsigned i = 0; i < myMatrix.size1 (); ++i) for (unsigned j = 0; j < myMatrix.size2 (); ++j) myMatrix(i, j) = 3 * i + j; return 0; } 

Ein vector > (beachte den Raum in > > ) kann gut funktionieren, aber es ist nicht unbedingt der effizienteste Weg, Dinge zu tun. Ein anderer, der ganz gut funktionieren kann, ist ein Wrapper um einen einzelnen Vektor, der die “Form” der dargestellten Matrix verfolgt und eine function oder einen überladenen Operator für den Zugriff auf die Daten bereitstellt:

 template  class matrix { int columns_; std::vector data; public: matrix(int columns, int rows) : columns_(columns), data(columns*rows) {} T &operator()(int column, int row) { return data[row*columns_+column]; } }; 

Beachten Sie, dass der C ++ – Standard es dem operator[] nur erlaubt, einen einzelnen Operanden zu verwenden, so dass Sie ihn zumindest für diesen Job nicht verwenden können. Im obigen Beispiel habe ich (offensichtlich genug) stattdessen operator() verwendet, sodass tiefgestellte Indizes eher wie Fortran oder BASIC aussehen, als Sie in C ++ gewohnt sind. Wenn Sie wirklich die [] -Notation verwenden möchten, können Sie es trotzdem tun, obwohl es leicht schwierig ist (Sie überladen es in der Matrix-class, um einen Proxy zurückzugeben, dann muss die Proxy-class auch den Überladungsoperator operator[] zurückgeben um) das richtige Element – es ist innerlich mild hässlich, funktioniert aber trotzdem ganz gut).

Edit: Da ich es herumliegen habe, hier ein Beispiel, wie man Letzteres umsetzen kann. Ich schrieb dies (eine ganze Weile), bevor die meisten Compiler std::vector enthielten, so dass es ein Array statisch zuordnet, anstatt einen Vektor zu verwenden. Es ist auch für den 3D-Fall (also gibt es zwei Ebenen von Proxies beteiligt), aber mit ein bisschen Glück kommt die Grundidee trotzdem durch:

 template class matrix3 { T data[size][size][size]; friend class proxy; friend class proxy2; class proxy { matrix3 &m_; int index1_, index2_; public: proxy(matrix3 &m, int i1, int i2) : m_(m), index1_(i1), index2_(i2) {} T &operator[](int index3) { return m_.data[index1_][index2_][index3]; } }; class proxy2 { matrix3 &m_; int index_; public: proxy2(matrix3 &m, int d) : m_(m), index_(d) { } proxy operator[](int index2) { return proxy(m_, index_, index2); } }; public: proxy2 operator[](int index) { return proxy2(*this, index); } }; 

Mit diesem können Sie das Array mit der normalen C ++ – Syntax adressieren, zum Beispiel:

 matrix3 m; for (int x=0; x 

Beispielcode:

 template class Array2D { public: Array2D(int a, int b) { num1 = (T**)new int [a*sizeof(int*)]; for(int i = 0; i < a; i++) num1[i] = new int [b*sizeof(int)]; for (int i = 0; i < a; i++) { for (int j = 0; j < b; j++) { num1[i][j] = i*j; } } } class Array1D { public: Array1D(int* a):temp(a) {} T& operator[](int a) { return temp[a]; } T* temp; }; T** num1; Array1D operator[] (int a) { return Array1D(num1[a]); } }; int _tmain(int argc, _TCHAR* argv[]) { Array2D arr(20, 30); std::cout < < arr[2][3]; getchar(); return 0; } enter code here