IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

Classe B imbriquées dans A


Sujet :

C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Nouveau membre du Club
    Profil pro
    Inscrit en
    Novembre 2006
    Messages
    6
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2006
    Messages : 6
    Par défaut Classe B imbriquées dans A
    Bonjour,

    J'ai eu beau beaucoup cherché, je n'ai pas trouvé la solution a cette question... J'ai deux classe, A et B et je voudrais les definir de cette façon:

    Classe A
    {
    prive:
    ...
    public:
    ....
    Classe B
    {
    ...
    };
    };
    Apparament la syntaxe n'est pas la bonne, car cela me genere des erreurs que je n'avais pas avant de les imbriquées. de meme, je me demandais comment il fallait les nommer lors de leur definission? Si vous pouviez m'aider

    merci beaucoup

  2. #2
    Expert confirmé

    Inscrit en
    Novembre 2005
    Messages
    5 145
    Détails du profil
    Informations forums :
    Inscription : Novembre 2005
    Messages : 5 145
    Par défaut
    Tu peux nous donner le code exact sur lequel tu veux qu'on commente. Parce que quand je vois classe et prive...

  3. #3
    Nouveau membre du Club
    Profil pro
    Inscrit en
    Novembre 2006
    Messages
    6
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2006
    Messages : 6
    Par défaut
    Le code est assez consequent, il genere plusieurs centaine de ligne, mais j'ai réussi a cerner le probleme. Il ne vient pas de l'inclusion lui meme mais dut faut que chacune des deux classes est un patron.On a:
    template <classe T> classe A
    {
    public:
    template <classe T> classe B
    {...};
    };
    Du fait que A est template, faut il preciser que B l'est aussi?

    Merci

  4. #4
    Expert confirmé

    Inscrit en
    Novembre 2005
    Messages
    5 145
    Détails du profil
    Informations forums :
    Inscription : Novembre 2005
    Messages : 5 145
    Par défaut
    Ma boule de cristal est en panne... Donne un exemple minimal qui reproduise ton problème.

  5. #5
    Nouveau membre du Club
    Profil pro
    Inscrit en
    Novembre 2006
    Messages
    6
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2006
    Messages : 6
    Par défaut
    Le plus simple est que je te donne une partie de mon code, j'ai essayé de mettre l'essentiel:
    ci joint le squelette de classe:
    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
    template <class T> class Iterateur;
     
    template <class T> class Liste
    {
     
    private:
       // pointeurs vers le premier et le dernier element
       Element<T>* premier;
       Element<T>* dernier;
     
       void coppy(const Liste&);  //Copie une liste
       void free();       // supprime une liste
     
    public:
           class Iterateur
            {
             public:
       // constructeur
       Iterateur();
     
       // retourne la valeur dans cette position
       T& operator *() const;
     
       // avance a la position suivante
       void operator ++ ();
     
       // recule a la position precedente
       void operator -- ();
     
       // compare deux iterateurs pour voir si ils sont égaux
       bool operator ==(const Iterateur& b) const;
     
       // Compare si deux iterateurs pour voir si ils sont differents
       bool operator !=(const Iterateur& b) const;
     
       //private:
       // pointeur vers l'element courant
       Element<T>* position;
     
       // pointeur vers le dernier element de la liste
       Element<T>* dernier;
      // friend class Liste <T>;
       };
     
       // constructeur
       Liste();
     
       // constructeur par recoppie
       Liste (Liste&);
     
       //destructeur
       ~Liste();
     
       // ajouter s a la fin de la liste
       void ajouter(const T& s);
     
       // ajouter s avant la position pos
       void inserer(const Iterateur& pos, const T& s);
     
       // supprimer l'element a la position pos
       void supprimer(Iterateur& pos);
     
       // la premiere position
       Iterateur debut() const;
     
       // la fin de la liste (apres la derniere position)
       Iterateur fin() const;
     
        // operateur d'affectation
       Liste& operator = (const Liste&);
     
          };
     
    #endif
    Et voici le fichier liste.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
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    template <class T> class Element
    {
    public:
       // constructeur
       Element(const T& s);
     
    private:
       T valeur;
     
       // pointeurs vers les voisins
       Element* precedent;
       Element* suivant;
     
    friend class Liste <T>;
    friend class Liste <T>::Iterateur;
    //friend class Iterateur;
    };
     
     
    template <class T> Element <T>::Element  (const T& s)
    {  valeur = s;
       precedent = suivant = NULL;
    }
     
     
    template <class T> Liste <T> ::Iterateur::Iterateur()
    {  position = dernier = NULL;
    }
     
    template <class T> T& Liste<T>::Iterateur::operator* () const
    {
       return position->valeur;
    }
     
    template <class T> void Liste<T>::Iterateur::operator ++ ()
    {  position = position->suivant;
    }
     
    template <class T> void Liste <T>:: Iterateur ::operator -- ()
    {  if (position == NULL) // fin de la liste
          position = dernier;
       else
          position = position->precedent;
    }
     
    template <class T> bool Liste <T>::Iterateur ::operator ==(const Iterateur& b) const
    {  return position == b.position;
    }
     
    template <class T>  bool Liste <T>:: Iterateur ::operator !=(const Iterateur& b) const
    {  return position != b.position;
    }
     
     
    template <class T> Liste <T> ::Liste()
    {  premier = dernier = NULL;
    }
     
     
    template <class T> Iterateur Liste <T>::debut() const
    {  Iterateur  it;
       it.position = premier ;
       it.dernier = dernier;
       return it;
    }
     
     
    template <class T> Iterateur Liste <T>::fin() const
    {  Iterateur  it;
       it.position = NULL;
       it.dernier = dernier;
       return it;
    }
     
    template <class T>  void Liste <T>::ajouter(const T &s)
     {
       Element <T>*nouveau = new Element <T>(s);
       if(dernier==NULL)
       {
        premier=dernier=nouveau;
       }
       else {
        nouveau->precedent=dernier;
    	 dernier->suivant=nouveau;
    	 dernier=nouveau;
    	 }
      }
     
      template <class T> void Liste <T>::inserer(const Iterateur &pos, const T &s)
      {
       Element <T> *nouveau = new Element <T>(s);
       Element <T> *p=pos.position;
       Element <T>*precedent=p->precedent;  //contenu de p->precedent
     
       if(p==NULL)
       {premier=dernier=nouveau;}
     
       else{
           p->precedent=nouveau;
            nouveau->precedent=precedent;
    	nouveau->suivant=p;
    	precedent->suivant=nouveau;
    	   }
       }
     
      template <class T> void Liste <T>::supprimer(Iterateur &pos)
       {
       Element <T> *p=pos.position;
       Element <T>*precedent=p->precedent;
       Element <T> *suivant=p->suivant;
     
       if(p==NULL)
       {premier=dernier=p;}
     
       else{
            precedent->suivant =suivant;
    	suivant->precedent=precedent;
    	}
       delete(p);
       }
     
       template <class T> void Liste <T>::coppy(const Liste &L)
       {
       premier=dernier=NULL;
       for(Iterateur it  =L.debut();it!=L.fin();it++)
        {
        ajouter(*it);
        }
       }
     
       template <class T> void Liste <T> ::free()
       {
       for(Iterateur it =debut();it!=fin();it++)
       {
        supprimer(it);
       }
       }
     
       template <class T> Liste <T> ::~Liste()
       {
        free();
       }
     
       template <class T> Liste <T>::Liste(Liste &l)
       {
         coppy(l);
       }
     
       template <class T> Liste& Liste <T>:: operator = (const Liste &l)
       {
       if(this!=&l)
       {
       free();
       coppy (l);
       }
       return *this;
       }

  6. #6
    Membre chevronné
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2006
    Messages
    366
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2006
    Messages : 366
    Par défaut
    ET en déclarant ta classe imbriquée de la manière suivante ? :

    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
    template <class T> class Iterateur;
     
    template <class T> class Liste
    {
     
    private:
       // pointeurs vers le premier et le dernier element
       Element<T>* premier;
       Element<T>* dernier;
     
       void coppy(const Liste&);  //Copie une liste
       void free();       // supprime une liste
     
    public:
           class Iterateur<T>
            {
             public
    //etc..

  7. #7
    Nouveau membre du Club
    Profil pro
    Inscrit en
    Novembre 2006
    Messages
    6
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2006
    Messages : 6
    Par défaut
    Je viens d'essayer et cela me genere une erreur.

    Avant de les imbriquer, class Iterateur et class Liste etait definit de la meme façon et le programme tourné.
    Mais il semblerait que le fait d'imbriquer Iterateur dans Liste enleve le template a la classe Iterateur. Mais du coup j'ai des probleme d'accesibilté. J'ai des erreurs du type: "Iterateur::postion is not accessible".

    J'ai essayer de mettre en public tt ce qui est en privé et cela ne change rien, donc a priori ce n'est pas un probleme d'accesseur!

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 0
    Dernier message: 20/02/2015, 10h38
  2. classe imbriquée dans 1 autre
    Par coold dans le forum C++
    Réponses: 6
    Dernier message: 31/05/2008, 00h42
  3. Réponses: 2
    Dernier message: 11/01/2006, 15h49
  4. Réponses: 4
    Dernier message: 08/10/2005, 09h31
  5. Probleme de Jointures imbriquées dans une requête
    Par Crevin dans le forum Langage SQL
    Réponses: 3
    Dernier message: 13/04/2005, 11h05

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo