héritage pile FiFo Lifo

Version imprimable

2 pièce(s) jointe(s)

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 142360

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
49
50
 
#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
Je ne sais pas comment le faire
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
 
#include "BasePile.h"
 
// PileFifo
 
//*** Surcharge de  l'operateur < (empiler)
PileFifo & PileFifo::operator < (int x){
 
}
//*** Surcharge de  l'operateur > (dépiler)
void PileFifo::operator > (int & x){
 
}
 
// 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){
 
}

1- Une pile c'est LIFO, sinon ce n'est pas une pile, donc, déjà le nommage est à l'Ouest.
2- C'est quoi le rapport avec C++/CLI
3- Pourquoi faire une roue carré ? http://www.cplusplus.com/reference/stack/stack/
4- Utiliser les opérateurs supérieurs et inférieur pour faire du push et du pop, vous cherchez vraiment les em***des avec toutes les bibliothèques à base de template.
5- Pourquoi les opérateurs < et > n'utilise pas les mêmes mécanismes que les opérateurs << et >> ?
6- Code tout pourri parce qu'utilisation de pointeurs nus (tout pourri)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 //*** 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; }

07/04/2014, 21h09
jockerse

Merci beaucoup pour la clarification et de l'assistance
Je suis encore débutant, je veux commencer par les bases, j'ai pas étudier encore la bibliothèque std
et pour Lifo comment le faire car n'est pas le même principe que Fifo
08/04/2014, 11h43
Médinoc

Un pile chaînée est plus facile à mettre en place qu'une file chaînée, car on n'a besoin de gérer qu'un seul bout de la pile: Le sommet (tête de la liste chaînée). Pas besoin de se casser le c*l à trouver la queue de la liste pour y ajouter un nouvel élément.

Citation:

Je suis encore débutant, je veux commencer par les bases, j'ai pas étudier encore la bibliothèque std

J'ai longtemps cru à ce principe, mais j'ai fini par me rendre compte qu'il était à l'envers: En fait, la bibliothèque standard, c'est les bases, et c'est seulement quand on approfondit qu'il est approprié de regarder sous le capot et construire une maquette de moteur. L'important, c'est de commencer par apprendre les bons réflexes, à savoir utiliser la bibliothèque standard dès que c'est approprié.