C'è un modo più naturale per rappresentare una matrice di T di un vettore < vector< T>>?

Question

Contesto:

Sto cercando di imparare C++ (leggendo alcuni dei libri consigliati dalla comunità di stackoverflow) e ho deciso di provare e creare un programma di automi cellulare con funzionalità di base solo per motivi di apprendimento (e perché è interessante per me).

Domanda:

C'è un modo più naturale per rappresentare una matrice di elementi cellulari che usare un vettore < vettore < cellulare >>? Sto cercando potenziali alternative nelle librerie standard o in alcune altre librerie popolari. Il commento riguardante la performance sarebbe apprezzato.

Non ho avuto problemi a utilizzare il vettore di vettori, né problemi con la sintassi, vorrei solo sapere le alternative. E dato che sono inesperto, ogni volta che scrivo del codice immagino che probabilmente ci sono molti modi più semplici per farlo che non troverei da solo.

Questa è la mia prima domanda, quindi se ho fatto qualcosa contro le linee guida per le domande, apprezzerei molto il fatto che tu l'abbia indicato.

Utile domanda relativa per riferimento futuro: Is a vector<vector<double>> a good way to make a make a matrix class?

Answer 1

Matrix<double, 13, 3> 

Dalla libreria Eigen3 http://eigen.tuxfamily.org/dox/group__QuickRefPage.html Eigen3 dà praticamente ogni operazione avrete bisogno per l'algebra lineare, ed è ben testato e utilizzato da una vasta base di utenti.

Answer 2

Ci sono generalmente due modi per rappresentare una matrice bidimensionale.

1. Un array di puntatori ad altri array, che è il modello std::vector<std::vector<T>> usi.

2. Un array ben confezionato contenente una riga dopo l'altra in memoria. Quindi l'elemento i, j può essere trovato a i + j * width.

Built-in array multidimensionali in C++ sono un po 'strano, in quanto condividono una sintassi simile a 1, ma il tipo
T[10][10] con i compilatori che conosco di attrezzi uno schema simile 2. Non lo so dalla parte superiore della mia testa se questo è richiesto dallo standard.

Answer 3

Sarei tentato di fare qualcosa del genere. Non so quanto vantaggio di velocità potrebbe avere su un vettore di vettori, quindi farei dei test per verificarlo. Presumo che avrà comunque qualche vantaggio di velocità.

typedef int Cell; 

int main() 
{ 
    // manage the raw multidimensional array pointer in a smart pointer 
    // so no need to worry about memory leaks 
    std::unique_ptr<Cell[][100]> cell_uptr(new Cell[100][100]); 

    // work from the raw pointer (maybe save a dereference?) 
    Cell(*cells)[100] = cell_uptr.get(); 

    for(size_t x = 0; x < 100; ++x) 
    { 
     for(size_t y = 0; y < 100; ++y) 
     { 
      // the compiler should be able to access cells[x][y] 
      // based on a simple calculation rather than a second dereference 
      cells[x][y] = 0; 
     } 
    } 
    // no need to worry about cleaning up 
} 

NOTA: Lo svantaggio di questo approccio è che il dimensioni dell'array è fisso in fase di compilazione.