matriz dinâmica de duas dimensões de acordo com a input

Eu preciso obter uma input N do usuário e gerar uma matriz N * N. Como posso declarar a matriz? Geralmente, o tamanho da matriz e matriz deve ser corrigido na declaração, certo? E quanto ao vector<vector> ? Eu nunca uso isso antes, então eu preciso de sugestão do veterano.

O Boost implementa matrizes (suportando operações matemáticas) em sua biblioteca uBLAS e fornece uma syntax de uso como a seguinte.

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

Um vector > (observe o espaço no > > ) pode funcionar bem, mas não é necessariamente a maneira mais eficiente de fazer as coisas. Outro que pode funcionar muito bem é um wrapper em torno de um único vetor, que controla a “forma” da matriz sendo representada e fornece uma function ou operador sobrecarregado para acessar os dados:

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

Observe que o padrão C ++ permite que o operator[] use um único operando, portanto você não pode usá-lo para este trabalho, pelo menos diretamente. No exemplo acima, eu usei (obviamente) operator() , então os subscritos parecem mais com Fortran ou BASIC do que você está acostumado em C ++. Se você está realmente usando a notação [] , você pode fazê-lo de qualquer maneira, embora seja um pouco complicado (você sobrecarrega na class matriz para retornar um proxy, então a class proxy também sobrecarrega o operator[] para retornar para) o elemento correto – é levemente feio internamente, mas funciona perfeitamente bem de qualquer maneira).

Edit: Desde que eu tenho por aí, aqui está um exemplo de como implementar o último. Eu escrevi isso (um bom tempo) antes que a maioria dos compiladores incluísse std::vector , então ele aloca estaticamente uma matriz ao invés de usar um vetor. É também para o caso 3D (então há dois níveis de proxies envolvidos), mas com um pouco de sorte, a idéia básica vem de qualquer maneira:

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

Usando isso, você pode endereçar a matriz com a syntax normal do C ++, como:

 matrix3 m; for (int x=0; x 

Código de amostra:

 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