Vettore multidimensionale

vector > a;

 std::vector< std::vector< int > > a; // as Ari pointed 

L’utilizzo di questo per una matrice crescente può diventare complesso, in quanto il sistema non garantisce che tutti i vettori interni abbiano le stesse dimensioni. Ogni volta che cresci nella seconda dimensione dovrai sviluppare esplicitamente tutti i vettori.

 // grow twice in the first dimension a.push_back( vector() ); a.push_back( vector() ); a[0].push_back( 5 ); // a[0].size() == 1, a[1].size()==0 

Se ciò va bene con te (non è realmente una matrice ma un vettore di vettori), dovresti stare bene. Altrimenti dovrai fare molta attenzione a mantenere stabile la seconda dimensione su tutti i vettori.

Se stai pianificando su una matrice di dimensioni fisse, dovresti prendere in considerazione l’incapsulamento in un operatore di class e di sovrascrittura () invece di fornire la syntax del doppio array. Leggi le domande frequenti su C ++ riguardo a questo qui

 std::vector< std::vector > a; //m * n is the size of the matrix int m = 2, n = 4; //Grow rows by m a.resize(m); for(int i = 0 ; i < m ; ++i) { //Grow Columns by n a[i].resize(n); } //Now you have matrix m*n with default values //you can use the Matrix, now a[1][0]=98; a[1][1]=989; a[1][2]=981; a[1][3]=987; //OR for(i = 0 ; i < m ; ++i) { for(int j = 0 ; j < n ; ++j) { //modify matrix int x = a[i][j]; } } 

Se non è necessario utilizzare i vettori, si consiglia di provare Boost.Multi_array . Ecco un link a un breve esempio.

Il suggerimento di dribeas è davvero la strada da percorrere.

Solo per dare un motivo per cui potresti voler seguire la rotta operator (), considera che, ad esempio se i tuoi dati sono sparsi, puoi disporli in modo diverso per risparmiare spazio internamente e operator () nasconde quel problema di implementazione interno da parte dell’utente finale che si incapsula meglio e si consente di creare spazio o velocità migliorando le modifiche al layout interno in un secondo momento senza interrompere l’interfaccia.

Come ha sottolineato Ari, il vettore > è il modo giusto per farlo.

In aggiunta a ciò, in questi casi considero sempre il wrapping del vettore interno (in realtà, qualunque esso rappresenti) in una class, perché le strutture STL complesse tendono a diventare maldestre e confuse.

Usa il seguente metodo per usare il vettore 2-D.

 int rows, columns; // . . . vector < vector < int > > Matrix(rows, vector< int >(columns,0)); Or vector < vector < int > > Matrix; Matrix.assign(rows, vector < int >(columns, 0)); // Do your stuff here... 

Ciò creerà una matrice di righe di dimensioni * colonne e la inizializzerà con zeri perché stiamo passando uno zero (0) come secondo argomento nel costruttore cioè vector (colonne, 0).

Dichiarazione di una matrice, ad esempio, con 5 righe e 3 colonne:

 vector > new_matrix(5,vector(3)); 

Un altro modo di dichiarazione per ottenere lo stesso risultato di cui sopra:

 vector Row; 

Una riga della matrice:

 vector My_matrix; 

My_matrix è un vettore di righe:

 My_matrix new_matrix(5,Row(3));