Discussion :

[kleenex]

Bonsoir tout le monde,

je cherche à faire un patron de classe dérivée d'un patron de classes.
Je rencontre un probleme a la ligne indiqué en rouge ci-dessous dans mon code!
Le compilateur me dit que la variable "_taille" est undeclared????
J'ai deux classes 1 conteneur virtuelle pure, et 1 tableau qui dérive de conteneur et qui est instanciable. Celle-ci devrait alors posséder les champs _taille et _taille_max de la table conteneur et pourtant dans la défintion des primitives de la classe tableau, le compilateur me dit que _taille est undeclared!
Je comprends pas. Je vous remercie par avance de votre aide.
Kleenex

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#include <iostream>


/*----------------------------------------------------------*/
/*               DECLARATION de la classe                   */
/*                  ****CONTENEUR****                       */
/*----------------------------------------------------------*/


template <class T>
class conteneur
{
      private:
              int _taille;
              int _taille_max;
      public:
             conteneur(int, int);
             ~conteneur();
             int taille_max() const;
             int taille() const;
             virtual void affiche(std::ostream &)const=0;
             bool est_vide() const;
             bool est_plein() const;

};

/*----------------------------------------------------------*/
/*      DEFINITION des fonctions membres de la classe       */
/*                 ****CONTENEUR****                        */
/*----------------------------------------------------------*/



/*----constructeur---*/
template <class T> conteneur<T>::conteneur(int taille, int max):_taille(taille),_taille_max(max)
         {
          std::cout<<"Construc. conteneur: "<<this<<std::endl;
         };
         
/*---destructeur---*/
template <class T>conteneur<T>::~conteneur()
         {
          std::cout<<"Destruc. conteneur: "<<this<<std::endl;
         };
         

template <class T> int conteneur<T>::taille_max() const
         {
          return _taille_max;
         };
         
         
template <class T> int conteneur<T>::taille() const
         {
          return _taille;
         };


template <class T> bool conteneur<T>::est_vide() const
         {
          return (_taille==0);
         };



template <class T> bool conteneur<T>::est_plein() const
         {
          return (_taille==_taille_max);
         };


/*----------------------------------------------------------*/
/*               DECLARATION de la classe                   */
/*                   ****TABLEAU****                        */
/*----------------------------------------------------------*/


template <class T>
class tableau:public conteneur<T> 
{
      private:
              T * _tab;
      public:
             tableau(int taille=10, int max=10, int init=0);
             ~tableau();
             void affiche(std::ostream &)const;
             T & operator[](int);
};


/*----------------------------------------------------------*/
/*      DEFINITION des fonctions membres de la classe       */
/*                   ****TABLEAU****                        */
/*----------------------------------------------------------*/

/*---constructeur---*/
template <class T> tableau<T>::tableau(int taille, int max, int init):conteneur<T>(taille,max), _tab(new T[max])
         {
          std::cout<<"Construc. tableau: "<<this<<std::endl;      
          for (int i=0; i<taille;i++)
              {
               _tab[i]=init;
              }
         };     

/*---destructeur---*/
template <class T> tableau<T>::~tableau()
         {
          delete[] _tab;
          std::cout<<"Destruct. tableau: "<<this<<std::endl;
         };
         
/*---surcharge de l'operateur []---*/
template <class T>  T &  tableau<T>::operator[](int i)
         {
          return _tab[i];
         };


template <class T> void tableau<T>::affiche(std::ostream & f)const
     {
      for (int i=0; i<_taille;i++)
          f<<_tab[i]<<" | ";
      f<<std::endl;
     };

[HanLee]

Il faut que tu mettes protected au lieu de private dans ta classe conteneur.

[Matthieu Brucher]

Le problème est plus sournois. Outre le fait de mettre protected au lieu de private, tu dois aussi rappeler au compilateur qu'il peut chercher dans le père, à savoir conteneur<T>. Donc soit tu ajoute explicitement devant _taille un conteneur<T>, soit tu mets dans la fonction ou la classe un using conteneur<T>::_taille.

[Luc Hermitte]

La norme exige de préfixer les membres des classes template par this-> quand on veut y accéder depuis le corps d'une fonction membre.

Quand au private, il est très bien, laisse le. D'autant que tu as un accesseur sur ta taille. Utilises ce dernier.

[kleenex]

merci pour vos réponses!
J'ai effectivement omis le protected.
J'aurais pu également passer par un accesseur. C'est les templates qui m'ont induit en erreur.

++