Tableau dynamique a 2 dimensions [Résolu/Fermé]

Signaler
-
Messages postés
1
Date d'inscription
samedi 2 novembre 2013
Statut
Membre
Dernière intervention
2 novembre 2013
-
Bonjour,

est-ce que quelqu'un saurait comment allouer un tableau dynamique a deux dimensions ?
Par exemple un tableau simple peut se faire avec:

int *tab = NULL;
tab = new int[20;

Merci d'avance
A voir également:

8 réponses

Messages postés
5
Date d'inscription
jeudi 7 février 2008
Statut
Membre
Dernière intervention
12 février 2008
22
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.
22
Merci

Quelques mots de remerciements seront grandement appréciés. Ajouter un commentaire

CCM 65492 internautes nous ont dit merci ce mois-ci

je dirais
delete [] tableau[i];
et
delete [] tableau;
Messages postés
1
Date d'inscription
samedi 2 novembre 2013
Statut
Membre
Dernière intervention
2 novembre 2013

Pour la désallocation je dirais pareil que godefroid
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.
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 ! :'(

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.
apprenez à programmer en c++ sur http://jmdesignstudio.kinssha.org/tutoriels_detail.php?table=tutoriels&id=40
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.
merci de nous expliquer c'est quoi allouer ?
tu est dans quel language ?