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

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

[bacelar]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[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

[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.

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é.