Tableau dynamique a 2 dimensions [Résolu]

Salut,

Il y a plusieurs méthodes possibles pour un tableau dynamique.

J'appelle,
ni : nombre de lignes
nc : nombre de colonnes.

- La première méthode ne pas déclarer un tableau de deux dimensions !!!

int* tableau;
tableau = new int [ ni * nc];

Après tu accède à tableau[i][j] par

tableau( i * nc + j)

Cette méthode évite de déclarer un tableau dynamique de deux dimensions mais n'est pas toujours évidente avec les indices.
Une solution est de se créer une fonction qui gère ca.

- La deuxième méthode, celle qui créé vraiment un tableau dynamique de deux dimensions

int ** tableau;
tableau = new int* [ni];
for ( int i=0 ; i < ni ; i++)
tableau[i] = new int [nc];
.
.
tableau[i][j]=...;
.
for ( int i=0 ; i < ni ; i++)
delete tableau [i];
delete tableau;


Voilà,
Personnellement j'utilise la première méthode la plupart du temps parce que je suis toujours en train d'oublier la deuxième.

Qu'elles sont les différences entre ces deux méthodes de déclarations ?

La première déclare un pointeur vers un tableau de ni * nc int qui est contigu dans la mémoire. (Pas très pratique quand on a des tableaux énormes et que la mémoire ne dispose pas d'un tel emplacement en continu ) .

La deuxième déclare un tableau de pointeur de longueur ni. Chaque pointeur de ce tableau pointe vers un tableau de int de taille nc.

J'espère que ca pourra t'aider.
Bonne programmation.

int* tableau;
tableau = new int [ ni * nc];

tableau( i * nc + j)

//
int ** tableau;
tableau = new int* [ni];
for ( int i=0 ; i < ni ; i++)
tableau[i] = new int [nc];
.
.
tableau[i][j]=...;
.
for ( int i=0 ; i < ni ; i++)
delete tableau [i];
delete tableau;

/***************************
Désolé, j'ai pas pu m'en empêcher:
****************************/
int *tableau;
tableau = new int[nbLigne* nbColone];
.
tableau[indexLigne * nbColone + indexColone]=...;
.

//
int **tableau;
tableau = new int*[nbLigne];
.
tableau[indexLigne][indexColone]=...;
.
for (int indexLigne = 0; indexLigne < nbLigne; indexLigne++)
{
delete tableau[nbLigne];
} // tres important de mettre les acolades (evite les erreurs de lecture)
delete tableau;

//NB: le systeme de post retire les <espace> au debut des lignes

Merci beaucoup,
mon probleme est resolu.

J'utilise le C++.
En C, pour creer un tableau dynamique, c'est a dire le creer au cours du programme en fonction d'une variable sans utiliser quelque chose du genre
int tableau[a];

on utilise:

nomdupointeur = malloc(bytes a allouer pour le tableau);
en C++ on utilse

nomdupointeur = new (type)[tailletableau];

Cependant, je ne sais pas comment allouer un tableau du gente
int tableau[10][10];
c'est a dire a 2 dimensions.

Bonjour, je viens de tester vos codes : (kshx2,aGuy) , pour l'allocation ça va mais j'ai la nette impression que pour que la désallocation laisse des fuites de mémoires :

//ALLOUER
tab = new CELL*[HEIGHT]; //Le constructeur de Cell écrit : std::cout<<"appel du constructeur de cell\n";
for(int j=0;j<HEIGHT;j++)
tab[j] = new CELL[WIDTH];


//DESALLOUER
MAP::~MAP()
{

for(int j=0;j<HEIGHT;j++)
delete tab[j]; //Le destructeur de Cell écrit : std::cout<<"appel du constructeur de cell\n";

delete tab;
}

Donc ensuite je j'instancie une map, puis je la supprimme
MAP *map = new MAP(3,3) // 3 et 3 correspondent à HEIGHT et WIDTH
delete map;


Dans la console j'ai bien 9 "appel du constructeur de cell";
Mais je n'ai que 3 "appel du destructeur de cell";
Ce qui me parait normal, vu qu'on ne fait pas delete tab[j][i] mais delete tab[j];
DONC fuite de mémoire !
probleme : delete tab[j][i]; me sort une erreur ! :'(

Rebonjour ;
Après deux trois manips j'ai trouvé la solution :

for(int j=0;j<HEIGHT;j++)
delete [](tab[j]); // delete[] supprime un tableau


Et voila le destructeur est appelé autant de fois que le constructeur, plus de fuites de mémoire !


Cordialement,
Darksheep.

pour pascal = setlenght(tableau,...)
mais tu peux trouver quelque chose ici

merci de nous expliquer c'est quoi allouer ?
tu est dans quel language ?