Discussion :

[kali38]

Bonjour,

Je voudrais savoir ce que signifie de faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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]

[Xtrem_Voyageur]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[kali38]

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?

[jo_link_noir]

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 :/)

[Xtrem_Voyageur]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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).

[kali38]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.