Discussion :

[jockerse]

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


j'ai le programme principale
l'empiler et le dépiler à l’aide d’une liste chaînée
main.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
 
#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 :

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
 
#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 :

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
 
#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 :

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
 
#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){
 
}