Problème d'accession d'un attribut pointeur protégé

**spawn385** · 10/12/2011, 01h44

Bonjour à tous... Comme l'indique le titre je n'arrive pas à accéder à un membre pointeur protégé de la classe File.Voici ma classe file:

HEADER:

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
#ifndef FILE_H
#define FILE_H
#include "Element.h"
class File
{
   protected : 
            //Représente le premier processus de la file
            Element *premier, 
            //Représente le dernier processus de la file
                    *dernier;
   public : //Constructeur
            File();
            //Constructeur de recopie
            File(const File&);
            //Destructeur
            ~File();
            //Opérateur d'affectation =
            File& operator= (const File&);
            //Fonction qui rempli la file contenant un ou plusieurs processus
            void enFile(const Element&);
            //Fonction qui enlève un quantum de temps sur le processus et qui le remet à l'arrière de la file si son temps d'exécution est supérieur à 0
            bool deFile(Element&);
            //Méthode afficher
            void afficher();           
};
#endif

.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
#include "File.h"
#include <iostream>
using namespace std;
 
//Constructeur
File :: File()
{
   premier = dernier = 0;
}
 
//Constructeur de recopie
//a revoir
File :: File(const File& f)
{
   Element* tampon = f.premier;
   while(dernier!=f.dernier);
   {   
      enFile(*tampon);
      tampon = tampon -> suivant;
   }             
}
 
//Destructeur
//A revoir
File :: ~File()
{
   Element* elementElimine = new Element();
   while(premier!=0)
   {
      elementElimine = premier -> suivant;
      delete [] premier;
      premier = 0;
      premier = elementElimine;      
   }
   delete elementElimine;  
}
 
//Opérateur d'affectation =
//A revoir
File& File :: operator= (const File& f)
{
   if(this != &f)
   {
      Element* elementCopie = new Element(*f.premier);
      while(elementCopie!=0)
      {
         enFile(*elementCopie);
         elementCopie = elementCopie-> suivant;          
      }
   }
   return *this;
}
 
//Fonction qui rempli la file contenant un ou plusieurs éléments
void File :: enFile(const Element& elementEnFile)
{
   Element * tampon = new Element(elementEnFile.getProcessus(),0);
      if (dernier != 0)                 // si la file n'est pas vide**********************************
         dernier->suivant = tampon;     // processus suivant***
      dernier = tampon;                 // si la file est vide le dernier élément sera égal au tampon*
      if (premier == 0)                 // si la file est vide le premier élément sera égal au tampon*
         premier = tampon;       
}
 
//Fonction qui remet à l'arrière de la file un processus si son temps d'exécution est supérieur à 0
//***A revoir
bool File :: deFile(Element &elementDeFile)
{
   if (premier == 0)                                     //file vide
      return false;
   else
   { 
      elementDeFile = *premier;
      if(premier->getProcessus().getTempsExecution()<=0)
      {
         premier = premier -> suivant;                   //premier pointe vers l'élément suivant
         elementDeFile=*dernier->suivant;               //elementDefile = 0
      }
      else                                              //lorsque l'élément est remis derrière la file
      {
         if(premier!=dernier)                           //S'il y a plus qu'un élément dans la file
         {
            premier = premier -> suivant;               //Premier va pointer vers l'élément suivant
            dernier = &elementDeFile;                   //dernier va pointer vers le premier élément(avant qu'il ne soit changé)
         }
      }
      return true;
   }
 
}
 
//Méthode afficher
void File :: afficher()
{
   Element* temp = premier;
   while (temp != 0)
   {    
      std::cout << temp->getProcessus().getNom() << "("<< temp->getProcessus().getTempsExecution() << ")" << " ";
      temp = temp->suivant;
   }
   std::cout << endl;   
}

Le but de mon programme est de simuler une file(queue) mais de façon manuelle.

merci du coup de pouce !

**Kaamui** · 10/12/2011, 01h52

Bonjour,

Il y a des balises pour le code

Code :

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

1
2
 
std::string exemple("C'est plus joli comme ça non ?");

Ne donne qu'un code minimal (un code qui ne contient QUE le code nécessaire pour reproduire l'erreur)

merci de rendre tout ça plus lisible, ensuite ce sera un plaisir de t'aider.

Cordialement,

**spawn385** · 10/12/2011, 19h30

Vraiment désolé pour ceci... Je viens de voir comment faire.
Il reste que je veux accéder à un attribut pointeur protégé à partir d'un objet de la classe même et j'y arrive pas.

**koala01** · 11/12/2011, 12h03

Salut,

Ton problème n'est, de toute évidence, pas là où tu le penses (dans la classe file)...

Je n'aurai la certitude de ce que j'avance que si tu nous donne l'erreur générée par le compilateur (car je présumes qu'il doit y en avoir

), mais je serais très tenté de dire que, si erreur il y a, ce serait en réalité au niveau de ta structure de donnée Element, et, plus précisément, lorsque tu essaye d'accéder à element->suivant (respectivement aux lignes 19, 30, 48, 59, 76, 77, 83 et 99 du code du cpp, si je n'en ai pas oubliées

)

Ces lignes me semblent en effet être les seuls endroits où tu tente d'accéder directement à des données de Element, et non à des fonctions de cette classe (ou structure)

Peut etre la donnée "suivant" est-elle privée dans la classe (ou dans la structure) Element

Pour rappel, en C++ classes et structures sont tout à fait équivalentes à une seule grosse exception près: la visibilité par défaut de leur contenu et de l'héritage éventuel qui est publique pour les structures et privé pour les classes

Regarde peut etre de ce coté là

**spawn385** · 13/12/2011, 00h47

Salut,
Premièrement, merci de ta réponse.

J'ai réussi à contourner le problème en modifiant ma solution.
Cependant il me reste un dernier pépin...
Tout roule sur des roulettes dans mon programme jusqu'à temps que je décide de détruire un élément de ma file. Il m'affiche alors un message d'erreur disant que l'objet ne peut être lu...

tout d'abord voici ou se trouve le problème j'en suis sur.
classe File méthode deFile

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
bool File :: deFile(Element &elementDeFile, int quantumTemps)
{
   if (premier == 0)                                     //file vide
      return false;
   else
   { 
      elementDeFile = *premier;                                     //l'adresse de l'élément de file contient le premier élément de la file.
      if(premier->getProcessus().getTempsExecution()<=quantumTemps) //si le temps d'exécution du premier élément est inférieur ou égal au quantum de temps
      {  
         premier = premier->suivant;                                //premier pointe vers l'élément suivant
         delete &elementDeFile;                                     //On efface l'ancien premier élément puisque son temps d'exécution est <= quantum de temps entré
      }
      else                                                          //lorsque le temps du processus de l'élément est supérieur au quantum de temps
      {
        elementDeFile.getProcessus().setTempsExecution(elementDeFile.getProcessus().getTempsExecution()-quantumTemps);   //Réduction du temps du premier processus de la file
         if(premier!=dernier)                                       //S'il y a plus qu'un élément dans la file
         {
            premier = premier -> suivant;                           //Premier va pointer vers l'élément suivant
            enFile(elementDeFile);
            elementDeFile.suivant = 0;
         }
         else
         {
            //dernier->getProcessus().setTempsExecution(dernier->getProcessus().getTempsExecution()-quantumTemps);
         }
      }
      return true;
   }                               
}

maintenant enfile

Code :

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

1
2
3
4
5
6
7
8
9
void File :: enFile(const Element& elementEnFile)
{
   Element * tampon = new Element(elementEnFile.getProcessus(),0);
      if (dernier != 0)                 // si la file n'est pas vide**********************************
         dernier->suivant = tampon;     // processus suivant***
      dernier = tampon;                 // si la file est vide le dernier élément sera égal au tampon*
      if (premier == 0)                 // si la file est vide le premier élément sera égal au tampon*
         premier = tampon;       
}

La partie du main.cpp qui utilise ces deux merveilleuses fonctions

Code :

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

1
2
3
4
5
6
7
 while(fileAttente->deFile(*elementaire,quantumTemps))
   {
      wait(quantumTemps);
      tempsCourant+=quantumTemps;
      cout << char(144) << "tat " << tempsCourant/quantumTemps << " apr" << char(138) << "s le " << tempsCourant/quantumTemps << "-e quantum de temps CPU(Q=" << quantumTemps << ") \t temps courant : " << tempsCourant << endl;
      fileAttente->afficher();      
   }

**koala01** · 13/12/2011, 11h06

Pourrais tu nous donner le code de ta classe Element, et, surtout, de son destructeur

**3DArchi** · 14/12/2011, 22h00

Salut,

Si c'est pour un projet pro alors mets ta classe file à la poubelle et regardes du côté de std::queue.
Sinon, ton code contient beaucoup d'erreurs et/ou de mauvaises pratiques :

Code :

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

1
2
3
4
5
 
File :: File()
{
   premier = dernier = 0;
}

Préférer les listes d'initialisations : Mes constructeurs doivent-ils utiliser les listes d'initialisation ou l'affectation ?

Code :

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

1
2
3
4
5
6
7
8
9
10
 
File :: File(const File& f)
{
   Element* tampon = f.premier;
   while(dernier!=f.dernier);
   {   
      enFile(*tampon);
      tampon = tampon -> suivant;
   }             
}

dernier n'est pas initialisé. Donc le while et enFile ne vont pas fonctionner

Code :

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

1
2
3
4
 
File :: ~File()
{
   Element* elementElimine = new Element();

Euh, une allocation dans un destructeur

Encore un échappé de Java/C#

En c++ : Element *elementElimine = 0;

Code :

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

1
2
3
4
5
6
7
8
9
10
 
   while(premier!=0)
   {
      elementElimine = premier -> suivant;
      delete [] premier;
      premier = 0;
      premier = elementElimine;      
   }
   delete elementElimine;  
}

delete [] ne s'applique que si tu as fait une allocation d'un tableau avec un new []. Ce qui ne me semble pas être le cas. Tu devrais donc faire un delete premier.
premier=0; ne sert à rien.
delete elementElimine en sortie de boucle, vu que la dernière instruction du while est premier = elementElimine et que la condition est while(premier!=0), je serais très surpris que la valeur de elementElimine soit différente de 0.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
File& File :: operator= (const File& f)
{
   if(this != &f)
   {
      Element* elementCopie = new Element(*f.premier);
      while(elementCopie!=0)
      {
         enFile(*elementCopie);
         elementCopie = elementCopie-> suivant;          
      }
   }
   return *this;
}

Tu as une fuite mémoire sur elementCopie. Idem que précédemment Element elementCopie = f.premier; devrait suffire.

Code :

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

1
2
3
4
5
6
7
8
9
10
//Fonction qui rempli la file contenant un ou plusieurs éléments
void File :: enFile(const Element& elementEnFile)
{
   Element * tampon = new Element(elementEnFile.getProcessus(),0);
      if (dernier != 0)                 // si la file n'est pas vide**********************************
         dernier->suivant = tampon;     // processus suivant***
      dernier = tampon;                 // si la file est vide le dernier élément sera égal au tampon*
      if (premier == 0)                 // si la file est vide le premier élément sera égal au tampon*
         premier = tampon;       
}

Le mélange dans Element de la valeur et du chaînage t'empêche d'utiliser le constructeur de copie de Element.

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
 
//Fonction qui remet à l'arrière de la file un processus si son temps d'exécution est supérieur à 0
//***A revoir
bool File :: deFile(Element &elementDeFile)
{
   if (premier == 0)                                     //file vide
      return false;
   else
   { 
      elementDeFile = *premier;
      if(premier->getProcessus().getTempsExecution()<=0)
      {
         premier = premier -> suivant;                   //premier pointe vers l'élément suivant
         elementDeFile=*dernier->suivant;               //elementDefile = 0
      }
      else                                              //lorsque l'élément est remis derrière la file
      {
         if(premier!=dernier)                           //S'il y a plus qu'un élément dans la file
         {
            premier = premier -> suivant;               //Premier va pointer vers l'élément suivant
            dernier = &elementDeFile;                   //dernier va pointer vers le premier élément(avant qu'il ne soit changé)
         }
      }
      return true;
   }
 
}

Cette fonction me déroute complètement

Je serais très surpris qu'elle fisse ce qu'elle est supposée faire.

Autre point, elle mélange des éléments de chaînage et d'autres qui n'ont rien à voir (temps d'exécution). Ce devrait être séparé : une fonction == une tâche bien identifiée.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
//Méthode afficher
void File :: afficher()
{
   Element* temp = premier;
   while (temp != 0)
   {    
      std::cout << temp->getProcessus().getNom() << "("<< temp->getProcessus().getTempsExecution() << ")" << " ";
      temp = temp->suivant;
   }
   std::cout << endl;   
}

Personnellement, je préfère mettre les affichage en dehors des classes. D'un point de vue pratique d'abord : l'affichage est quelque chose qui change souvent. D'un point de vue design, je pense qu'il s'agit d'un aspect indépendant de la classe.

Problème d'accession d'un attribut pointeur protégé

C++

Discussions similaires

Partager

Partager