Comment définir un tableau 2D en C++ et STL sans manipulation de la mémoire?

Il y a plusieurs façons de définir un tableau 2D en C++ et STL sans manipulation de la mémoire, et les codes suivants illustrent deux méthodes différentes:

int main () 
{
    /**************
        1   2   3
        4   5   6
    ***************/
    //Method 1
    const int ROW = 2;
    const int COL = 3;
    int array1[ROW][COL];
    for(int i=0; i<ROW; i++)
        for(int j=0; j<COL; j++)
            array1[i][j] = i*COL+j+1;

    //Method 2
    typedef vector<vector<int> > ARRAY; 
    ARRAY array2;
    vector<int> rowvector;
    for(int i=0; i<ROW; i++)
    {
        rowvector.clear();
        for(int j=0; j<COL; j++)
            rowvector.push_back(i*COL+j+1);
        array2.push_back(rowvector);
    }
    return 0;
}

Ma question est: existe-il d'autres façons de définir le tableau 2D? Lequel est le plus efficace? Merci!

int **arr2D ;
Bon tuto sur les tableaux en C++
Si votre tableau est de taille constante utilisez la méthode 1. Si votre tableau a une taille déterminée lors de l'exécution, utilisez la méthode 2. De plus, de moins en moins utile méthodes pour la 2d tableaux sont std::array<std::array<int, COL>, ROW> et boost tableaux multidimensionnels.

OriginalL'auteur feelfree | 2012-10-11

  1. 4

    il existe d'autres moyens de définir le tableau 2D?

    Pas sans manipulation de la mémoire explicitement (malloc/free). Si vous utilisez statique alloué array (1er exemple) vous allouer l'espace au moment de la compilation, de sorte que vous ne pouvez pas ajouter plus de lignes ou de colonnes lors de l'exécution.

    Le deuxième exemple utilise std::vector qui cache à vous allocation dynamique de la mémoire . De cette façon, vous pouvez éventuellement ajouter beaucoup plus de lignes ou de colonnes lors de l'exécution.

    Si vous n'avez pas besoin de modifier dynamiquement la dimension de la matrice, puis la première solution est la plus simple et la plus rapide (même si je pense que std::vector mise en œuvre est assez rapide pour être comparable au tableau statique, plus élégant et plus orienté objet).

    Si vous avez besoin de modifier la dimension de la matrice au moment de l'exécution utiliser std::vector, car il vous évite d'avoir à traiter directement avec malloc et free.

    donc, soit on doit connaître la taille au moment de la compilation et de l'utilisation std::array ou de choisir entre std::vector et new/malloc. Si seulement il y avait une taille immuable std:array qui n'a pas besoin de connaître la taille à l'avance qui pourrait être utilisé pour de nombreuses applications comme les images que j'obtiens plus de réseau que je ne peut pas savoir la taille, mais lorsque la taille est connu je n'ai pas besoin de l'appoint de la complexité de std::vector

    OriginalL'auteur Heisenbug

  2. 16

    En C++11 utilisation std::array:

      std::array<std::array<int,3>,2> a {{
    {{1,2,3}},
    {{4,5,6}}
 }};

    Certaines d'utilisation:

      a[0][2] = 13;

    OriginalL'auteur PiotrNycz

  3. 7

    Une méthode très efficace pour définir des tableaux est de l'allocation dynamique, à l'aide de la new et delete opérateurs. Voici un exemple:

    int **arr=new int*[ROW];
for( int i=0; i<ROW; ++i ) {
  arr[i] = new int[COL];
  for( int j=0; j<COL; ++j ) {
    arr[i][j] = some_val;
  }
}

    Le grand avantage de cette approche est que, si vous n'avez pas besoin de plus de mémoire que le tableau, vous pouvez facilement le supprimer. Voici un exemple de suppression d'un tableau 2D:

    for( int i=0; i<ROW; ++i ) {
  delete[] arr[i];
}
delete[] arr;

    OriginalL'auteur Rontogiannis Aristofanis

  4. 6

    Un modèle commun est l'encapsulation de l'2D tableau à l'intérieur d'une classe qui offre l'interface appropriée. Dans ce cas, vous pouvez utiliser d'autres représentations internes, comme par exemple un vecteur unique de rows*cols éléments. L'interface (généralement operator()(int,int) sera carte, les coordonnées de l'appelant à une position dans le vecteur linéaire.

    L'avantage est qu'il est de l'allocation dynamique, mais une allocation unique (contrairement à la std::vector<std::vector<int>> où chaque vecteur doit acquérir sa propre mémoire) et dans un seul bloc de fournir la localité des données.

    OriginalL'auteur David Rodríguez - dribeas

  5. 6

    Il y a beaucoup de compromis ici.

    Si vous déclarez un style C tableau 2D int array[height][width], alors vous avez vraiment obtenir un seul bloc contigu de mémoire. Le compilateur convertit indices à leurs 1D adresse

    array[row][col] == *(array + row * width + col)
    • Avantages: cohérence de cache. Toute la mémoire est dans le même endroit.
    • Inconvénients: vous avez besoin d'une multiplication pour chaque indexation. Indirection pourrait être plus rapide.

    Si vous utilisez un vector de vectors, puis chaque ligne est attribué séparément. L'extérieur vector stocke des pointeurs à l'intérieur vectors. L'indexation devient une indirection suivie d'un ajout: 

    array[row][col] == *(*(array + row) + col)
    • Avantages: indirection peut être plus rapide que la multiplication.
    • Inconvénients: pas de cache cohérent, puisque chaque ligne est attribué séparément (à moins que l'application optimise pour vector<vector>).

    Si la performance est vraiment important, vous avez besoin de tester les deux et de déterminer qui est plus rapide sur vos données.

    êtes-vous sûr de cohérence de cache? êtes-vous sûr que chaque ligne est attribué séparément?
    Je suppose que le TSL mise en œuvre pourrait avoir une optimisation pour vector de vector.

    OriginalL'auteur japreiss

  6. 4

    Pour déclarer un tableau 2D à l'aide de std::vector, vous pouvez utiliser ce type de construction:

    vector<vector<int> >  matrix( n, vector<int>(m, -1) );

    Cela crée un tableau 2D matrix de taille n par m, avec tous les éléments initialisés à -1.

    En gros, c'est une imbrication de la "initialiser avec n objets de valeur à l' val" constructeur:

    vector (size_type n, const value_type& val,
                 const allocator_type& alloc = allocator_type());

    (constructeur définition copié à partir de ici)

    OriginalL'auteur MatthewD

  7. 0

    Si vous connaissez les éléments avant de la main, alors vous pourriez faire

    int arr[3][3] = {{1,2, 3}, {4, 5, 6}};

    Cela devrait être plus efficace que method1 et method2.À l'aide de vecteur ne faisons pas de la manipulation de la mémoire vous-même, mais le vecteur de la mise en œuvre sera probablement utiliser un tableau alloué dynamiquement.

    OriginalL'auteur kkg