Allocation dynamique en memoire

Bonjour,

Je voudrais savoir ce que signifie de faire:

Code:

---

1 2	Couleur* grille= new Couleur[taille*taille]

---

Il me semble que Couleur* grille veut dire qu'on alloue un pointeur grille sur une Couleur et que new Couleur[taille*taille] alloue de l'espace en mémoire et renvoi l'adresse pointé par grille?

ce qui me perturbe c'est surtout le fait de faire [taille*taille] que je ne pige pas très bien cette expression si c'est une matrice pourquoi on ne ferais pas [taille][taille]

Si tu as une matrice d'entiers de taille N*M donc N lignes et M colonnes, tu peux en effet la déclarer de 2 façons.

Code:

---

1 2 3

int matrice[N][M]; // Dans ce cas on accède aux éléments en faisant matrice[i][j] avec 0<= i <= N et 0<= j <= M mais également en faisant matrice[i*M+j] int matrice[N*M]; // Ici, tu accèdes à l'élément matrice[i][j] en faisant matrice[i*M+j]

---

Quoi qu'il en soit en mémoire, que tu déclares un tableau double ou simple, tes éléments seront contigus en mémoire, donc en gros en mémoire, c'est un tableau simple de taille N*M. Et voilà pourquoi en déclarant un double tableau, tu peux toujours accéder aux éléments à l'aide d'un simple indice.

euh j'ai pas tous pigé sur ton argumentation concernant l'accès au éléments...et comment on peux parcourir tous les éléments?

Se que dit Xtrem_Voyageur est valable pour un tableau sur la pile. Un tableau sur le tas (alloué avec new) ne peut pas être initialisé avec new int[n][m] car cette syntaxe voudrait dire "un pointeur pouvant contenir N pointeur de M int (un int **)". Hors, un int** n'est pas un tableau aligné car chaque colonne est allouer indépendamment des lignes (new alloue un bloc de donnée, pas une multitude de bloc). Pour avoir un segment aligné, il faut un bloc de N*M int.


tableau une dimension de taille (5*2):

int int int int int int int int int int

(10 int alignés)


tableau deux dimensions de taille (5*2)

int * -> int int
int * -> int int
int * -> int int
int * -> int int

(5 int* alignés + 10 int alignés par groupe de 2)


(Mon explication est quelque peu brouillon :/)

Oui, j'ai été un peu rapide.
Si tu tiens absolument à utiliser la notation standard tant utile en algèbre linéaire, tu peux mais il faut modifier ta déclaration.
En effet au lieu d'allouer un segment mémoire. Il va falloir que tu utilises un double pointeur pour pointer sur un tableau de pointeurs de Couleur.
Chacun de ces pointeurs dans ce tableau devra lui même s'allouer un tableau de Couleurs. Ce n'est pas très compliqué mais cela demande plus
de lignes de code.

Code:

---

1 2 3 4 5 6

Couleur **grille = new Couleur*[N]; for(int i = 0; i <N; ++i) { grille[i] = new Couleur[M]; } // Et là tu peux utiliser ta grille avec la notation grille[i][j] en contrôlant tes i,j pour qu'ils restent dans les bornes, cela va sans dire.

---

Ce qui implique de libérer correctement la mémoire.

Code:

---

1 2 3 4 5

for(int i = 0; i < N; ++i) { delete [] grille[i]; // Ici on libère la mémoire occupée par les N tableaux de M Couleurs. } delete [] grille; // Ici on libère la mémoire occupée par la tableau de N pointeurs sur des Couleurs.

---

Donc tu vois avec qu'avec la première notation, tu n'as qu'une allocation à faire, et une seule libération de mémoire.

Sinon tu peux aussi utiliser des conteneurs de la STL comme std::vector, cela serait plus simple et serait plus dans l'optique de coder en C++

Code:

---

1 2 3 4 5 6 7 8

using std::vector; vector<vector<Couleur> > grille; grille.resize(N); for(int i = 0; i < N; ++i) { grille[i].resize(M); } // Tu as accès à un élément via la notation grille[i][j] comme tu voulais

---

Et là, tu n'as plus à te soucier de la mémoire. L'objet vector a un allocateur de mémoire par défaut qui se charge de ça pour toi.
(Attention tout de même si tu veux un vecteur de pointeurs, mais on ne va pas pousser plus loin pour le moment).

Ok mais dans ce cas la il m'est difficile d'interpréter un bout de code, que g tiré d'un livre, à partir de ce que vous venez de m'expliquer.

la classe Jeu:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#ifndef JEU_HPP #define JEU_HPP   #include "Joueur.hpp" #include <iostream> using namespace std;   class Jeu { public: Jeu(unsigned int t = 8); Jeu(const Jeu&); virtual ~Jeu();   Jeu& operator=(const Jeu&); bool jouer(unsigned int numero, Couleur couleur); unsigned int get_taille() const { return taille; } ostream& affiche(ostream& sortie) const; protected: unsigned int taille; Couleur* grille; };   #endif

---

Jeu.cpp:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

bool Jeu::jouer(unsigned int numero, Couleur couleur) { if(couleur==vide) return false; if(numero>=taille) return false; const unsigned int k(taille*numero); unsigned int j(0); while((j<taille) && (grille[k+j] != vide)) ++j; if(j>=taille) return false; grille[k+j] = couleur; return true; }

---

Je n'ai pas tous mis, juste l'aspect parcours des elements dans la matrice carrée. C'est tiré d'un exercice de puissance 4 et l'objectif est de placer un jeton de couleur dans une colonne dont le numero est passé en paramètre. J'ai essayé de le decortiquer mais ca correspond pas avec vos explications

Desolé d'être aussi insistant mais j'ai besoin de comprendre ce mecanisme ca me parait important de le comprendre.

ah oui et la memoire est alloué de facon dynamique dans le livre de cette facon:

Code:

---

1 2 3 4 5 6

Jeu::Jeu(unsigned int t) { taille = t; grille = new Couleur[taille*taille]; }

---

Tout dépend de la représentation que tu choisis.
Dans la vrai vie, ton jeu de puissance 4 peut se représenter ainsi.
A B C D
E F G H
I J K L
M N O P

Notons les colonnes de 0 à 3 et les lignes de 0 à 3.
Si tu insères un jeton en colonne 2, tu pourras l'insérer en O si O est libre, sinon en K si K est libre, ... en remontant ta colonne.

Si dans ton programme tu as choisi de représenter ton puissance 4 avec une matrice identique à mon dessin c'est à dire où
grille[0][0] = A, ..., grille[0][3] = D
....
grille[3][0] = M, ..., grille[3][3] = P
alors il faut vérifier pour insérer un jeton en colonne 2 que grille[i][2] est libre pour i=0, puis pour i=1 si c'est occupé pour i = 0, etc..
mais grille[i][2] correspond à grille[i*taille+2] dans ton code vu que tu as un tableau simple.
En mémoire, les éléments ont été placé comme cela : A B C D E F G H I J K L M N O P

L'auteur lui a décidé pour des raisons pratiques de représenter sa matrice comme cela
M I E A
N J F B
O K G C
P L H D
et vu qu'il utilise un tableau simple, ses éléments sont en mémoire disposés dans l'ordre suivant : M I E A N J F B O K G C P L H D
Donc tu vois bien que pour insérer un jeton en colonne 2 il toujours vérifier que O est libre puis K est libre, mais cette fois cela correspond à
grille[2][j] pour j allant de 0 à 3 ou encore dans ton code à grille[2*taille + j] pour j allant de 0 à 3.

Mais ne mélanges pas les 2 problèmes que tu as.
Le premier qui est comment allouer et libérer de la mémoire en C ++ pour des tableaux simples ou doubles.
Le deuxième étant plus conceptuel vis à vis de l'exercice et comment représenter un jeu de puissance 4 en mémoire.

Dans ton exemple, il traite d'un tableau 2D comme d'un tableau 1D :

Code:

---

1 2 3

ABCD EFGH IJKL

---

Peut être vu comme :

Code:

---

ABCDEFGHIJKL

---

Pour un tableau à 2 dimensions de M lignes et N colonnes, on alloue alors un tableau à 1 dimension de M*N cases.
Et là où tu voulais accéder à la case (i,j), il te faudra accéder à la case (i*taille d'une ligne + j).

Dans ton exemple, l'allocation new Couleur[taille*taille]; indique donc un tableau carré, ayant taille comme nombre de lignes et colonnes. Pour accéder à une case, on a bien :

Code:

---

1 2 3

const unsigned int k(taille*numero); //.... grille[k+j] = couleur;

---

Ce qui correspond à mon (i*taille d'une ligne + j), sauf qu'il a inversé lignes et colonnes, ce qui est parfaitement autorisé, ce n'est qu'une convention (c'est à dire que dans mon tableau mis à plat, il aurait vu AEIBFJCGKDHL), et qui doit représenter le fait que pour un puissance 4, il souhaite donner plus d'importance à la colonne qu'à la ligne, en particulier pour savoir où s'arrête un pion que l'on met en jeu.

Ah ok c bon j'ai parfaitement bien compris avec vos explications...et merci d'avoir pris le temps de tous détailler :)