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 !