héritage FiFo Lifo

1 pièce(s) jointe(s)

héritage FiFo Lifo

Bonjour;
j'ai le diagramme de classe suivant, les classe PileFifo et PileLifo hériter de la classe BasePile, et chaque pile se compose des cellule
Pièce jointe 142375

j'ai le programme principale
l'empiler et le dépiler à l’aide d’une liste chaînée
main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
#include "BasePile.h"
using namespace std;
int main(int argc, char** argv) {
    BasePile * ptPile;
    PileFifo fifo;
    PileLifo lifo;
    ptPile = &fifo;
    //FIFO
    *ptPile < 0 < 1;
    cout<<"pile="<<*ptPile;
    int i;
    *ptPile > i;
    cout<<"pile="<<*ptPile<<"i="<<i;
    ptPile=&lifo;
    //LIFO
    *ptPile < 0 < 1;
     cout<<"pile="<<*ptPile;
    *ptPile > i;
    cout<<"pile="<<*ptPile<<"i="<<i;
    return 0;
}

je fais la classe cellule
Cellul.h

Code:

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
 
#ifndef CELLUL_H
#define	CELLUL_H
#include <iostream>
using namespace std;
class Cellul {
    friend class BasePile;
    friend class PileFifo;
    friend class PileLifo;
    int info;
    Cellul * succ;
public:
 
    Cellul(int x=0){
        cout<<"construction cellule";
       info=x;
       succ=NULL;
    }
 
    ~Cellul(){
        delete succ;
    }
 
};
#endif

et la classe BasePile
BasePile.h

Code:

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
 
#ifndef BASEPILE_H
#define	BASEPILE_H
#include <iostream>
using namespace std;
#include "Cellul.h"
 
class BasePile {
protected:
    Cellul * last; // le dernier noeud inserer
public:  
    virtual void operator > (int & x)=0; //surcharge de  l'operateur > (dépiler) méthode abstraite
    virtual BasePile & operator < (int x)=0; //surcharge de  l'operateur > (empiler) méthode abstraite
    friend ostream & operator<<(ostream & , BasePile & ); // surcharge de l'operateur d'affichage
 
    BasePile(){
        last=NULL;
        cout<<"Constructeur par defaut de BasePile";
    }
 
    bool vide(){
        if(last == NULL)
            return true;
        else
            return false;
    }
 
    ~BasePile(){
        if(last != NULL)
            vide();
    }
};
 
 
 
class PileFifo:public BasePile{
public:
    void operator>(int& x);
    PileFifo & operator < (int x);
};
 
 
class PileLifo:public BasePile{
public:
    void operator>(int& x);
    PileLifo & operator < (int x);
};
#endif

j'ai un problème pour les surcharge de l'operateur empiler,dépiler pour PileFifo et PileLifo et l'affichage de chaque pile
Je ne sais pas comment le faire :( je fais pour Fifo mais je ne sais pas est ce que correcte ou nn
S'il vous plaît aidez-moi

BasePile.cpp

Code:

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
 
#include "BasePile.h"
 
// PileFifo
 
//*** Surcharge de  l'operateur < (empiler)
PileFifo & PileFifo::operator < (int x){
   Cellul* tmp = last;
   last = new Cellul(x);
   last->succ = tmp;
}
//*** Surcharge de  l'operateur > (dépiler)
void PileFifo::operator > (int & x){
   x = last->info;
   Cellul* tmp = last;
   last = last->succ;
   delete tmp;
}
 
// PileLifo
 
//*** Surcharge de  l'operateur < (empiler)
PileLifo & PileLifo::operator<(int x){
 
}
//*** Surcharge de  l'operateur > (dépiler)
void PileLifo::operator > (int & x){
 
}
 
//*** redefinition de l'operateur << 
ostream & operator << (ostream & s, BasePile & p){
 
}

J'ai l'impression que tu t'es un peu emmêler les pinceaux, et du coup j'avoue avoir du mal à m'y retrouver dans ton code.
(et bien sur je pense que tu réalise ses classes à but purement éducatif, et non pas pour un besoin réel)

Quel est le type derrière Cellul ?

Tes valeurs que tu entre, tu ne les stock pas dans un Vector ? Tableau ? Quelque chose ?

J'ai personnellement trop de mal à savoir ce que fond certain bout de ton code pour te répondre.
Qu'est-ce qui ne va pas ? (A part les fuites de mémoires ^^)

ça compile ? Y-a-t-il des Warning ? Les sorties ne sont pas correctes ?

FIFO, ce n'est pas une pile, c'est une file.

Ta classe BasePile, tu devrais l'appeler ListeChainee.