matriz dinámica de dos dimensiones según la entrada

Necesito obtener una entrada N del usuario y generar una matriz N * N. ¿Cómo puedo declarar la matriz? En general, el tamaño de la matriz y matriz se debe fijar en la statement, ¿verdad? ¿Qué pasa con vector<vector> ? Nunca uso esto antes, así que necesito una sugerencia del veterano.

Boost implementa matrices (admite operaciones matemáticas) en su biblioteca uBLAS y proporciona una syntax de uso como la siguiente.

 #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; } 

Un vector > (tenga en cuenta que el espacio en el > > ) puede funcionar bien, pero no es necesariamente la forma más eficiente de hacer las cosas. Otro que puede funcionar bastante bien es un envoltorio alrededor de un solo vector, que realiza un seguimiento de la “forma” de la matriz que se está representando, y proporciona una función u operador sobrecargado para acceder a los datos:

 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]; } }; 

Tenga en cuenta que el estándar C ++ solo permite que el operator[] tome un solo operando, por lo que no puede usarlo para este trabajo, al menos directamente. En el ejemplo anterior, he (obviamente) utilizado operator() lugar, por lo que los subíndices se parecen más a Fortran o BASIC de lo que está acostumbrado en C ++. Si realmente está usando la notación [] , puede hacerlo de todos modos, aunque es un tanto complicado (lo sobrecarga en la clase de matriz para devolver un proxy, y luego la clase proxy también sobrecarga el operator[] para devolver (una referencia a) el elemento correcto – es levemente feo internamente, pero funciona perfectamente bien de todos modos).

Editar: Ya que lo tengo por ahí, aquí hay un ejemplo de cómo implementar este último. Escribí esto (bastante tiempo) antes de que la mayoría de los comstackdores incluyesen std::vector , por lo que asigna estáticamente una matriz en lugar de usar un vector. También es para el caso 3D (por lo que hay dos niveles de proxies involucrados), pero con un poco de suerte, la idea básica aparece de todos modos:

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

Al usar esto, puede abordar la matriz con la syntax normal de C ++, como por ejemplo:

 matrix3 m; for (int x=0; x 

Código de muestra:

 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