Tableau d'allocation dynamique de la mémoire en 2D en C++

Question

Il y a quelques jours, j'ai appris sur internet comment créer des tableaux de mémoire allouée en 2D, cela fonctionne parfaitement. Pour accéder au tableau, il suffit d'utiliser matrix[i][j] Cependant, existe-t-il un moyen de déréférencer ce tableau 2D en utilisant la fonction * au lieu de la notation [] pour les contributions ainsi que d'autres méthodes ?

La première question est de savoir si je peux utiliser *(*(matrix + i) + j)

Maintenant j'ai une autre question, le dernier segment de code est pour libérer la mémoire allouée (je l'ai eu sur internet aussi), mais je ne le comprends pas, pourquoi je ne peux pas juste utiliser delete [] matrix ?

int **matrix;

// dynamically allocate an array
matrix = new int *[row]; 
for (int count = 0; count < row; count++)
{
    matrix[count] = new int[col];
}

// input element for matrix
cout << endl << "Now enter the element for the matrix..."; 
for (int i=0; i < row; i++) 
{
    for (int j=0; j < col; j++)
    {
        cout << endl << "Row " << (i+1) << " Col " << (j+1) << " :";
        cin >> matrix[i][j]; // is there any equivalent declaration here?
    }
}

// free dynamically allocated memory
for( int i = 0 ; i < *row ; i++ )
{
    delete [] matrix[i] ;   
}
delete [] matrix ;

Answer 1

Pour répondre à votre deuxième question, lorsque vous allouez un tableau 2D avec le code suivant

// dynamically allocate an array
    matrix = new int *[row]; 
    for (int count = 0; count < row; count++)
        matrix[count] = new int[col];

vous allouez en fait un tableau de pointeurs (votre variable matrice, qui est un double pointeur) et des tableaux "row" d'entiers (chacun représentant une ligne de votre matrice, de taille "col"), qui sont matrix[0] , matrix[1] etc. jusqu'à matrix[row-1] .

Ainsi, lorsque vous voulez libérer votre matrice, vous devrez d'abord libérer chaque ligne (les tableaux alloués dans la boucle), puis le tableau qui contenait les lignes. Dans votre cas, le code que vous utilisez pour libérer votre matrice est partiellement erroné, et devrait ressembler davantage à ce qui suit :

// free dynamically allocated memory
for( int i = 0 ; i < row ; i++ )
{
    //first we delete each row
    delete [] matrix[i] ;
}
//finally, we delete the array of pointers
delete [] matrix ;

Le delete dans la boucle libérera chaque ligne de votre matrice, et le delete final libérera le tableau de lignes. Dans votre code, vous utilisez delete row fois sur votre double pointeur ( matrix ), ce qui n'a aucun sens.

Enfin, l'utilisation d'un simple effacement sur le double pointeur est une erreur, car cela entraînerait une fuite de mémoire, puisque vous ne libérez pas la mémoire allouée à chaque ligne, mais uniquement les pointeurs qui y font référence.

Answer 2

Desde a[b] est juste *(a + b) vous pouvez bien sûr le faire :

*(*(matrix + i) + j)

Bref, ces new Les allocations sont sujettes à des erreurs. Si l'un des éléments imbriqués new s lance alors vous aurez une fuite. Essayez d'utiliser std::vector à la place.

Answer 3

Quelque chose comme ça pourrait fonctionner :

int **matrix;

// dynamically allocate an array
matrix = new (std::nothrow) int *[row];
if (matrix == NULL)
{
      // handle the error
}
for (int count = 0; count < row; count++)
{
    *(matrix + count) = new (std::nothrow) int[col];
    if (matrix[count] == NULL)
    {
          // handle the error
    }
 }

cout << "\nNow enter the element for the matrix..."; 
for (int i=0; i < row; i++)
{
    for (int j=0; j < col; j++)
    {
        cout << "\nRow " << (i+1) << " Col " << (j+1) << " :";
        cin >> *(*(matrix + i) + j);
    }
}

Answer 4

Oui, vous utilisez l'addition de pointeurs, mais vous devez comprendre comment la mémoire est disposée. Disons que x est un pointeur vers le premier élément d'un tableau d'ints, si vous voulez accéder à x[2], vous pouvez utiliser *(x+2). Cependant, avec les matrices, cela peut devenir assez confus et vous avez beaucoup plus de chances d'accéder à de mauvais indices dans votre matrice si vous faites cela, donc je ne vous le conseille pas.

Answer 5

Vous pourriez faire *(*(matrix+i)+j) . Cela devrait être équivalent à la notation entre parenthèses. Ce qui se passe avec les deux notations est simplement arithmétique des pointeurs .