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

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

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, 00h52

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, 18h30

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, 11h03

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** · 12/12/2011, 23h47

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, 10h06

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

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

C++

Vue hybride

Discussions similaires

Partager

Partager