Utilisation de la mémoire vive par un programme

**Pixcoder** · 22/09/2006, 17h23

Salut!

J'utilise Dev C++ 4.9 et je voulais savoir si le compilateur limitait la quantité de mémoire vive utilisée par le programme, et dans pareil cas, si l'on pouvait la modifier cette quantité.

Si DevC++ ne le pemet pas, est ce qu'un autre compilateur le permet?

Je demande tout ceci parce que j'ai de sérieux problèmes d'allocation de mémoire , allocation que je provoque grâce à des appels à "new". J'attrape les erreurs avec des try{} et des catch{} associés.
Les allocations ressemblent à la suivante :

Code :

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

1
2
3
4
5
6
7
8
    try
    {
      visible_cubes = new CList<int>* [n*p*h];
    }
    catch(exception &exc)
    {
      Erreur(  exc.what()  );
    }

D'autre part, le programme quitte à cette erreur sans bien m'exécuter ma fonction nommée "Erreur()". Il est vrai que mes allocations sont importantes et c'est pour cela que je me suis demandé si le compilateur ne limitait pas la mémoire pouvant être utilisée.

J'espère que vous avez compris mon problème!

PiX

**loufoque** · 22/09/2006, 17h30

Il semblerait que tu n'aies pas trop compris comment s'utilise CList.

je voulais savoir si le compilateur limitait la quantité de mémoire vive

Non.
C'est le système qui s'occupe de cette gestion et ceci à l'execution.

**Pixcoder** · 22/09/2006, 17h43

Ah, peutêtre que CList existe déjà; en réalité ici, j'ai créé CList donc j'en connais logiquement son utilisation.

**rigobert** · 22/09/2006, 20h23

Envoyé par Pixcoder

Ah, peutêtre que CList existe déjà; en réalité ici, j'ai créé CList donc j'en connais logiquement son utilisation.

Dans ce cas si le code suivant :

Code :

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

1
2
3
4
5
try
{
    visible_cubes = new CList<int>* [n*p*h];
}
catch(exception &exc)

lève une exception, c'est qu'il y a un bug ... dans l'implémentation de ta classe

!

Et sans savoir comment elle est implémentée, on ne pourra pas faire grand chose pour t'aider...

**loufoque** · 22/09/2006, 22h07

c'est qu'il y a un bug ...

Ou alors qu'il y a eu une erreur lors de l'allocation mémoire.

**Luc Hermitte** · 23/09/2006, 01h02

Tu es sûr de ne pas planter après le new ?
Je ne vois pas pourquoi une allocation d'un tableau de pointeurs de Toto devrait échouer autrement qu'en levant une std::exception (std::bad_alloc pour être plus précis). (a part avec un vieux GCC qui ne lève pas d'exceptions par défaut, une inclusion de <new>, ce genre de choses)

Ca sent plutôt le plantage dans le code qui suit qui tenterait de remplir les Toto pointés non alloués. Rajoutes donc une trace juste après ton allocation. Et vois la FAQ au sujet des tableaux à plusieurs dimensions.

J'imagine que tu réinventes la roue parce qu'il s'agit d'un exercice ?

**NewbiZ** · 24/09/2006, 14h50

On pourrait avoir une idée de l'ordre de grandeur de n, p et h ?
Ainsi qu'un sizeof(CList<int>) ?

**Pixcoder** · 24/09/2006, 22h05

n = 12
p = 12
h = 11
et sizeof(CList<int>) = 40

J'ai même tenté de remplacer l'allocation de mémoire grâce à 'new' par un 'allocator<CList<int> *>' et lors de l'allocation de mémoire, il me quitte le programme de la même manière!

Regardez la 3ème image sur ce site
http://rom3fr.free.fr
Elle présente le bug que j'ai eu pendant un moment tout à fait dans les mêmes conditions que précédemment, c'est-à-dire lors de cette allocation de mémoire.

Luc Hermitte : Non, il ne s'agit pas d'un exercice... Que me conseilles tu d'utiliser comme "structure" de mémorisation de classes prédéfinies, ici CList<int> * ?

PiX

**Pixcoder** · 24/09/2006, 22h12

Luc Hermitte : lorsque que je faisun "system("pause");" juste avant cette allocation et que j'en place un autre juste après, lors de l'éxécution, il me fait la première pause et dès que j'appuis sur une touche pour continuer, le programme quitte prématurément sans aucun message d'erreur, sans rien...

Je ne comprends pas la cohérence de ce comportement, parfois il me sort l'erreur de la 3eme image et parfois il quitte le programme comme ca...

PiX

**Luc Hermitte** · 24/09/2006, 22h42

Ton truc est hyper louche. Montre nous un exemple mininal mais complet !
Ca sent vraiment un problème de corruption. Il a peut-être lieu avant ton allocation de pointeurs de tableaux.

Une structure à utiliser ? Ben il y a plein de choses qui marchent très bien dans la SL. Si tu veux de la double dimension, il faut soit de l'huile de coude, soit utiliser des bibliothèques déjà existantes (qui ont l'avantage d'avoir déjà été validées).
Jettes un coup d'oeil à la FAQ.

**Pixcoder** · 24/09/2006, 23h13

Voici la méthode à l'origine de l'erreur. Elle fait parti d'un lot de fonctions qui charge chacune une partie du fichier. Quand je l'enlève et que je fais les modifs nécessaires pour ne plus avoir à utiliser ce qu'elle était censée charger, le programme se lance correctement.

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
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
void CMap::LoadListsOfVisibleCubes(FILE *filepointer)
{     
 
 
 
    fscanf(filepointer, "Visible cubes filename\n");
 
    //let us read the number of characters of the file to load
    unsigned int nbchar;
    fscanf(filepointer, "%d\n", &nbchar);     
 
 
 
 
    char *path;
    try
    {
      path = new char[nbchar];
    }
    catch(exception &exc)
    {
      Erreur(  "Allocation error, map.cpp"  );
    }    
 
 
 
    fscanf(filepointer, "%s\n\n", path);
 
 
 
 
    //now let us load the file
    FILE *filepointer2;
 
    if ((filepointer2=fopen(path, "r"))==NULL)
       Erreur("Error loading the visible cubes file, map.cpp");
 
    //displaying what is happening
    printf("\n\nLoading the visible cubes list ...\n");    
 
    printf("  allocating memory for 'visible_cubes'\n");
 
 
  system("pause");
 
  visible_cubes = new(std::nothrow) CList<int>* [n*p*h];
  if (visible_cubes == NULL)
    Erreur("Error allocating memory, 'visible_cubes', map.cpp");
 
  system("pause");    
 
 
    for (int i=0; i<n*p*h; i++)
    {
 
 
          try
          {
            visible_cubes[i] = new CList<int>;
          }
          catch(exception &exc)
          {
            Erreur(  "Allocation error, map.cpp"  );
          }    
 
          //reading the coordinates of the current position
          int id;
          fscanf(filepointer2, "id cube : %d, ", &id);
          unsigned int coordx, coordy, coordz;
          fscanf(filepointer2, "coordinates : %d %d %d\n", &coordx, &coordy, &coordz);          
          fscanf(filepointer2, "Visible cubes' indices : ");
 
 
 
          //reading the indices of the visible cubes;          
          int visible_cubes_index;
          fscanf(filepointer2, "%d ", &visible_cubes_index);
 
 
          while(visible_cubes_index != -1)
          {                
 
                 visible_cubes[i]->AjouterDebut(visible_cubes_index);
                 fscanf(filepointer2, "%d ", &visible_cubes_index);                                                 
          } //end while
 
          fscanf(filepointer2, "\n\n");
 
    }  //end (int i=0; i<n*p*h; i++)
 
    fclose(filepointer2);
    if (path != NULL)
      delete[] path;
 
    printf("\nVisible cubes lists loaded.\n\n");
 
 
 
 
}

Les commentaires sont en anglais, excusez moi.

Pour info, voici le code de CList :

List.h

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
25
26
27
28
29
30
31
32
33
34
35
36
37
 
#ifndef LIST_H
#define LIST_H
 
template <class T>
struct CMaillon
{
	//Champs contenu par un maillon (Modifiable, mais attention de bien modifier aussi le code des methodes suivantes : CMaillon(), operator =(CMaillon m)
	T Contenu;
 
	//Champs qui réalisent le chainage dans la liste
	CMaillon<T>* Suivant;
	CMaillon<T>* Precedent;
 
	//Methodes
	CMaillon();//Contructeur : initialise le maillon
	void operator =(CMaillon<T> m);//Affectation d'un maillon à un autre maillon
};
 
 
template <class T>
class CList
{
private:
	CMaillon<T>* Premier;//Pointeur sur le premier élément de la liste
	CMaillon<T>* Dernier;//Pointeur sur le dernier élément de la liste
public:
	CList();//Initialisation de la liste à la liste vide
	CMaillon<T>* AjouterDebut(T o);//Ajoute un maillon au début de la liste et renvoie un pointeur vers ce maillon	
	CMaillon<T>* GetPremier();//Renvoie le premier élément de la liste
	CMaillon<T>* Suivant(CMaillon<T>* m);//Renvoie l'élément qui est le suivant du maillon m dans la liste
	void Supprimer(CMaillon<T>* MaillonASupprimer);//Supprime le maillon pointé par MaillonASupprimer de la liste
	bool ListeVide();//Indique si la liste est vide ou non
	void DetruireListe();// Vide la liste de tout ses éléments en les effaçant
};
 
#endif

List.cpp

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
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
#include "List.h"
 
/*******************************************************************************************************************************\
|                                     DEFINITION DES METHODES DE CMaillon                                                       |
\*******************************************************************************************************************************/
 
template <class T>
CMaillon<T>::CMaillon()
{
	//Contenu=NULL;
	Suivant=NULL;
	Precedent=NULL;
}
 
template <class T>
void CMaillon<T>::operator =(CMaillon<T> m)
{
	Contenu=m.Contenu;
}
 
/*******************************************************************************************************************************\
|                                     DEFINITION DES METHODES DE CList                                                          |
\*******************************************************************************************************************************/
template <class T>
CList<T>::CList()
{
	Premier=NULL;
	Dernier=NULL;
}
 
template <class T>
CMaillon<T>* CList<T>::AjouterDebut(T o)
{
	CMaillon<T>* Nouveau=new CMaillon<T>;
	Nouveau->Contenu=o;
	Nouveau->Suivant=Premier;
	Nouveau->Precedent=NULL;
	if(Dernier==NULL)Dernier=Nouveau;
	else Premier->Precedent=Nouveau;
	Premier=Nouveau;
	return Nouveau;
}
 
 
 
 
 
template <class T>
CMaillon<T>* CList<T>::GetPremier()
{
	return Premier;
}
 
template <class T>
CMaillon<T>* CList<T>::Suivant(CMaillon<T>* m)
{
	return m->Suivant;
}
 
template <class T>
void CList<T>::Supprimer(CMaillon<T>* MaillonASupprimer)
{
	if((MaillonASupprimer!=NULL)&&(Premier!=NULL))
	{
		if(MaillonASupprimer==Premier)
		{
			Premier=Premier->Suivant;
			if(Premier!=NULL)Premier->Precedent=NULL;
			else Dernier=NULL;
			delete MaillonASupprimer;
		}
		else if(MaillonASupprimer==Dernier)
		{
			Dernier=Dernier->Precedent;
			Dernier->Suivant=NULL;
			delete MaillonASupprimer;
		}
		else
		{
			MaillonASupprimer->Precedent->Suivant=MaillonASupprimer->Suivant;
			MaillonASupprimer->Suivant->Precedent=MaillonASupprimer->Precedent;
			delete MaillonASupprimer;
		}
	}
}
 
 
 
 
template <class T>
bool CList<T>::ListeVide()
{
	return (Premier==NULL);
}
 
 
 
 
 
template <class T>
void CList<T>::DetruireListe()
{
	while(Premier!=NULL)Supprimer(GetPremier());
}

**Pixcoder** · 24/09/2006, 23h15

Il faut noter que la méthode présentée void CMap::LoadListsOfVisibleCubes(FILE *filepointer) charge un nom de fichier (variable 'path') qui se trouve dans le fichier chargé par le "lot de méthodes", puis après avoir chargé ce nom de fichier, elle charge le fichier en question.

PiX