problème d'allocation de mémoire

Version imprimable

Salut Tlm,

J'ai un petit probleme d'allocation de memoire je pense.
J'ai beaucoup de mal a l'identifier.

je peux creer des grilles de taille 4 et plus mais pas de taille 2 ou 3....:(

qqun peut il m'eclairer svp

merci bcp

--------------------------------------------------------------------------

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#ifndef GRILLE_HPP
#define GRILLE_HPP
 
class Grille {
 
      public:
             Grille(int dim);
             Grille(Grille &g);
             ~Grille();
             int getDimension();
             int getValeur(int x, int y);
             bool ligneEstVide(int x);
             bool colonneEstVide(int y);
             void ViderPosition(int x, int y);
             void afficher();
 
      private:
             int dimension;
             int** tabValeurs;
 
};
 
#endif

--------------------------------------------------------------------------

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include "Grille.hpp"
#include <iomanip>
#include <iostream>
 
using namespace std;
 
Grille :: Grille(int dim) {
    tabValeurs = new int * [dimension = dim];
    for (int i = 0; i < dimension ; i++){
        tabValeurs[i] = new int [dimension];
        for (int j = 0; j < dimension; j++){
            tabValeurs[i][j] = 0;
        }
    }
}
 
Grille :: Grille(Grille &g) {
    tabValeurs = new int * [g.dimension];
    for (int i=0;i<g.dimension;i++){
        tabValeurs[i] = new int [g.dimension];
        for (int j = 0;j < g.dimension; j++){
            tabValeurs[i][j] = g.tabValeurs[i][j];
        }
    }
}
 
Grille :: ~Grille() {
    delete tabValeurs;
}
 
int Grille :: getDimension(){
    return dimension;
}
 
int Grille :: getValeur(int x, int y){
    return tabValeurs[x][y];
}
 
bool Grille :: ligneEstVide(int x){
     for (int i = 0;i<dimension;i++){
         if (tabValeurs[x][i]!=1111){
            return false;
         }
     }
     return true;
}
 
bool Grille :: colonneEstVide(int y){
     for (int i = 0;i<dimension;i++){
         if (tabValeurs[i][y]!=1111){
            return false;
         }
     }
     return true;
}
 
void Grille :: ViderPosition(int noLigne, int noColonne) {
     tabValeurs[noLigne][noColonne] = 1111;
}
 
void Grille :: afficher(){
	for ( int i = 0; i < dimension; ++i ) {
		for ( int j = 0 ; j < dimension; ++j ) {
			cout << "|";
            cout << setw(3) << tabValeurs[i][j];
            cout << " |";
		}
		cout << endl << endl;
	}
}

--------------------------------------------------------------------------

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
    //Grille grille(2);
    //Grille grille1(3);
    Grille grille2(4);
    Grille grille3(5);
    Grille grille4(6);
    Grille grille5(7);
    Grille grille6(8);
    //cout<<grille.getDimension()<<endl;
    //cout<<grille.getValeur(2,2)<<endl;
    //cout<<grille.getValeur(3,3)<<endl;
    //cout<<grille.getValeur(1,1)<<endl;
    grille6.afficher();
    grille5.afficher();
    grille4.afficher();
    grille3.afficher();
    grille2.afficher();
    //grille1.afficher();
    //grille.afficher();

--------------------------------------------------------------------------

18/10/2007, 02h39
koala01
Salut, et bienvenue sur le forum.

Quelques remarques préliminaires:
1. Il est peu recommandé de faire deux choses à la fois, surtout s'il s'agit d'allouer de la mémoire pour un membre et d'en initialiser un autre
2. Il est des plus intéressant d'utiliser les listes d'initialisation dans le constructeur
3. Si tu crées une boucle pour allouer dynamiquement de la mémoire, il te faut une boucle pour libérer correctement toute la mémoire
4. Sais tu qu'il n'y a rien de plus proche d'un tableau à deux dimensions qu'un tableau à une seule :question: si tu reste dans des dimensions raisonables (je dirais > à 1000*1000), cela peut te faciliter la vie :roll:
Dans l'ordre, cela signifie que, dans le constructeur, la ligne

Code:

tabValeurs = new int * [dimension = dim];

est une véritable horreur pour les yeux (après trois jours sans avoir touché à ce code, je te mets au défis de te rappeler tout de suite que tu initialise dimention au passage :roll:)
et serait avantageusement remplacée, au pire, par
Code:

1 2 dimention=dim; tabValeurs = new int *[dimention];
Mais, la deuxième remarque aidant, on préférera carrément un code ressemblant à
Code:

1 2 3 4 5 Grille::Grille (int dim):dimention(dim) { tabValeurs = new int *[dimention]; /*...*/ }
La remarque en [3] est motivée par le destructeur:

Lorsque, après avoir fait un
Code:

1 2 3 4 5 tabValeurs = new int *[dimention]; for (int i = 0; i < dimension ; i++) { tabValeurs[i] = new int [dimension]; }
tu te contente d'un

Code:

delete[] tabValeurs;

cela ne provoque absolument pas la libération de la mémoire qui avait été allouée pour tabValeurs[0] à tabValeurs[dimention]...

Ce phénomène s'appelle les "fuites mémoire" (memory leaks en anglais), et fait que, plus tu créera et détruira des objets du type concerné (ici grille), plus tu te retrouvera avec une quantité importante de mémoire que le système considère comme utilisée par l'application, mais à laquelle on n'a plus aucun moyen d'accéder :roll:

A la longue, cela peut entraîner un tas de problèmes, allant du simple ralentissement au plantage pur et simple de l'application (si pas du système complet), et il vaut donc mieux éviter d'en arriver là :P

Pour éviter le problème, le destructeur devrait ressembler à
Code:

1 2 3 4 5 6 Grille ::~Grille() { for(int i=0;i<dimention;i++) delete[] tabValeurs[i]; delete[] tabValeurs; }
Et cela nous emmène tout droit à la remarque [4]...

Etant donné qu'il est très facile d'oublier de libérer la deuxième dimension avant de libérer la première, et que, de toutes manière, la mémoire ne se présente quand même que sous la forme d'un tableau à une dimension, on peut se baser sur le fait qu'une grille de X lignes et de Y colonnes n'est jamais qu'une "représentation visuelle" de X*Y cellules ;)

L'avantage étant que l'on peut alors demander l'allocation dynamique de toute la mémoire ne une seule fois sous la forme générique de

Code:

type* tab = new type[X*Y];

et bien évidemment la libération de la mémoire en une seule fois aussi sous la forme de

Code:

delete[] tab;

L'inconvénient principal réside dans le fait... qu'on court beaucoup plus de risques - si le nombre de lignes et de colonnes est important - que le système ne trouve plus autant de mémoire contiguë disponible...

Mais bon, si cela peut t'inciter à gérer la mémoire en "bon père de famille", c'est un moindre mal :D

Il reste le détail de la manière d'accéder aux différentes cellules à aborder avec cette optique, et, pour ne pas me lancer (encore une fois :oops:) dans un roman, je me contenterai de te fournir la formule sous forme d'une petite fonction (explications sur demande:D)
Code:

1 2 3 4 5 type Grille::GetCellule(int ligne, int colonne) { return tab[ligne*nbcolonne + colonne] }
où nbcolonne est le nombre total de colonnes présentes dans la grille

Et puis du coup...
A vouloir tout faire d'un coup... on en oublie....

Comme le constructeur par recopie qui n'initialise pas dimension...
Et donc, devrait faire planter:

Code:

1
2
3
4
 
Grille a(20);
Grille b(a);
Grille c(b);

Et il manque aussi un opérateur d'affectation.

Un code genre:

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
inline Grille::Grille(int dim) : m_dim(0), m_data(0)
{
    set(dim,0);
}
inline Grille::Grille(const Grille& g) : m_dim(0), m_data(0)
{
    set(g.m_dim,g.m_data);
}
inline Grille& operator=(const Grille& g)
{
    if (&g != this) {
        reset();
        set(g.m_dim,g.m_data);
    }
    return *this;
}
inline Grille::~Grille(void)
{
    reset();
}
 
void Grille::set(int dim, const int* data)
{
    assert(m_data == 0); // juste histoire d'être sur
    if (dim > 0) {
        size_t size = dim * dim;
        m_data = new int [size];
        if (m_data) {
           if (data)
               memcpy(m_data,data,sizeof(int)*size);
           m_dim = dim;
        }
    }
}
 
void Grille::reset()
{
    if (m_data) {
         delete [] m_data;
         m_data = 0;
    }
    m_dim = 0;
}