Classe pile dynamique

Soyez le premier à donner votre avis sur cette source.

Vue 11 576 fois - Téléchargée 515 fois

Description

J'ai un projet de C++ : faire une classe pile en dynamique...
je vais le rendre demain donc svp regardez et critiquez!!!donnez moi des conseils ou dites moi ce qui ne va pas.....( j'ai eu quelques problemes donc ça m'étonnerai pas kil y en ai),hésitez pas et j'essayerai de corriger avant de rendre ça demain!!
merci d'avance.......

[ j'ai fais ça sous Dev C++]

Source / Exemple :


//=======================================ClassPile.h
#ifndef _PILE_H_
#define _PILE_H_
#include <string>

using namespace std;

class Pile {

public:
	struct element { string _nom ; short unsigned int _priorite;} ;
	
    // Constructeurs et destructeur
	Pile();
	Pile(const int);
	Pile(const Pile & tmp);
    ~Pile();

    Pile & operator = (const Pile & tmp);
    void viderPile();

    // Affichages et acesseurs
	int afficherPriorite(const int i) const {return (_tab[i]._priorite);};
	string afficherNom(const int i) const {return (_tab[i]._nom);};
	void afficherPile();
    	friend ostream & operator << (ostream & affichage,const Pile & pile);

    // Fonctions mofifiant la pile
    	void allongerPile();
    	void empiler();
    	void empiler(const string & chaine,const int & priorite);
    	void depiler(const string & chaine);
    
    // Fonctions diverses
	void sauvegarder() const;
	void charger();

private:
      int _taille;
      int _longueur;
      element * _tab;
};
#endif

//=======================================ClassPile.C
#include "ClassPile.h"
#include <iostream>
#include <fstream.h>
#include <string>
#include <ctype.h>
const int NBCASES=3;

using namespace std;

//=====================================Pile()
// Constructeur sans paramètre
//=====================================
Pile::Pile() {
   	_taille=10;
	_longueur=0;
	_tab=new element[_taille];
}

//=====================================Pile(int)
// Constructeur prenant la taille
// en paramètre
//=====================================
Pile::Pile(const int tmp) {
  	_taille=tmp;
	_longueur=0;
	_tab=new element[_taille];
}

//=====================================Pile(int)
// Constructeur prenant une pile
// en paramètre
//=====================================
Pile::Pile(const Pile & tmp) {
    _tab=new element[tmp._taille];
    _taille=tmp._taille;
    _longueur=tmp._longueur;
    for(int i=0;i<_longueur;i++)
        {
         _tab[i]=tmp._tab[i];
        }
}

//=====================================~Pile()
// Destructeur de pile
//=====================================
Pile:: ~Pile() {
	delete [] _tab;
}

//=====================================operateur =
// Operateur = pour premettre
// l'affectation de pile
//=====================================
Pile & Pile::operator = (const Pile & tmp) {
    if (this==&tmp) return *this;
    delete [] _tab;
    _tab=new element[tmp._taille];
    _taille=tmp._taille;
    _longueur=tmp._longueur;
    for(int i=0;i<_longueur;i++) {_tab[i]=tmp._tab[i];}
	return *this;
}

//=====================================viderPile()
// Effacer le contenu d'une pile
//=====================================
void Pile::viderPile() {
for(int i=0;i<_taille;i++) {_tab[i]._priorite=0;_tab[i]._nom="";}
}

//=====================================afficherPile()
// Afficher le contenu d'une pile
//=====================================
void Pile::afficherPile()
{
cout<<"__________________________"<<endl;
cout<<"-- Affichage de la pile --"<<endl<<endl;
cout<<"Taille de la pile:"<<_taille<<"  Nombre de cases utilisees:"<<_longueur<<endl<<endl;
cout<<"Priorite | Nom"<<endl;
for (int i=0;i<_taille;i++)
	{
	cout<<"   "<<afficherPriorite(i)<<"        "<<afficherNom(i)<<endl;
	}
}

//=====================================operateur <<
// Fonction amie qui affiche le
// contenu d'une pile
//=====================================
ostream & operator << (ostream & affichage,const Pile & pile) {
affichage<<"__________________________"<<endl;
affichage<<"-- Affichage de la pile --"<<endl<<endl;
affichage<<"Taille de la pile:"<<pile._taille<<"  Nombre de cases utilisees:"<<pile._longueur<<endl<<endl;
affichage<<"Priorite | Nom"<<endl;
for (int i=0;i<pile._taille;i++)
	{
	affichage<<"   "<<pile.afficherPriorite(i)<<"        "<<pile.afficherNom(i)<<endl;
	}
}

//=====================================empiler()
// Fonction saisie les elements
// à empiler
//=====================================
void Pile::empiler() {
  short unsigned int priorite;
  string ch;
  cout<<"Entrez la chaine: ";cin>>ch;
  cout<<"Entrez la priorite: ";cin>>priorite;
  empiler(ch,priorite);
}

//=====================================empiler(string,short unsigned int)
// Fonction qui empile un element 
// directement
//=====================================
void Pile::empiler(const string & chaine,const int & priorite)
{
if ( priorite<=0 || priorite>=66536) { cout<<"Erreur : la priorite doit être un nombre entier"<<endl;}
else {
if (_taille==_longueur) allongerPile();
int indice=0;
while( _tab[indice]._priorite <= priorite && indice<_longueur && _tab[indice]._priorite>0 ) {indice++;}

if (indice<_longueur)
	{
	for(int i=_longueur;i>=indice;i--)
		{
		if(_tab[i]._priorite!=0) (_tab[i+1])=(_tab[i]);
		}
	}
_tab[indice]._priorite=priorite;
_tab[indice]._nom=chaine;
_longueur++;
}
};

//=====================================empiler(string)
// Fonction qui depile un element
//=====================================
void Pile::depiler(const string & chaine)
{
int ind=_longueur,i;
do { ind--; }
while( ind>0 && afficherNom(ind)!=chaine);

if(ind==0 && afficherNom(ind)!=chaine) cout<<"L'element n'est pas présent dans la pile"<<endl;
else {
_tab[ind]._nom="";
_tab[ind]._priorite=0;
if (ind!=_longueur-1) {
	for(i=ind;i<_longueur;i++)
		{
		_tab[i]=_tab[i+1];
		}
	_tab[i]._nom="";
	_tab[i]._priorite=0;
	}
_longueur--;
}
};

//=====================================sauvegarder()
// Sauvegarde d'une pile dans un
// fichier texte
//=====================================
void Pile::sauvegarder() const
{
ofstream save("Pile.txt");
save<<_taille;
for (int i=0;i<_taille;i++)
	{
    save<<endl;
	save<<afficherPriorite(i)<<" "<<afficherNom(i);
	}
save.close();
cout<<endl<<"-- Pile sauvegardee !   --"<<endl<<endl;
}

//=====================================charger()
// Chargement d'une pile à partir d'un
// fichier texte
//=====================================
void Pile::charger()
{
int indice=0,entier,tailleTmp;
string chaine;
ifstream load("pile.txt");
load>>tailleTmp;
Pile tmp(tailleTmp);
tailleTmp=0;
while( ! load.eof() )
{
    load>>entier>>chaine;
	tmp.empiler(chaine,entier);
    tailleTmp++;
}
_longueur=tailleTmp;

  • this=tmp;
delete [] tmp._tab; load.close(); cout<<endl<<"-- Pile chargee ! --"<<endl<<endl; } //=====================================allongerPile() // Pour allonger une pile dynamiquement //===================================== void Pile::allongerPile() { Pile tmp(NBCASES); tmp._longueur=_longueur; for (int i=0; i<_taille; i++) {tmp._tab[i]=_tab[i];}
  • this=tmp;
_taille=tmp._taille; _longueur=tmp._longueur; delete [] tmp._tab; } //====================================Prog.C #include "ClassPile.h" #include <iostream> #include <string> using namespace std; int main() { int choix; /* do { cout<<"Que voulez-vous faire?"<<endl; cout<<" [1]:Afficher la pile"<<endl; cout<<" [2]:Empiler"<<endl; cout<<" [3]:Depiler"<<endl; cout<<" [4]:Sauvegarder"<<endl; cout<<" [5]:Charger"<<endl; cout<<" [6]:Quitter"<<endl; cin>>choix; } while(choix!=1 && choix!=2 && choix!=3 && choix!=4 && choix!=5 && choix!=6);
  • /
int i; short unsigned int prio; string ch; cout<<"Debut du programme\n"<<endl; Pile e1(5); /*for(int i=0;i<3;i++) { e1.empiler(); }*/ e1.empiler("a",1); e1.empiler("z",2); e1.empiler("e",3); e1.afficherPile(); cout<<"\nEntrez la chaine a depiler:";cin>>ch; e1.depiler(ch); e1.afficherPile(); cout<<"\nFin du programme"<<endl; cin>>i; return 0; }

Conclusion :


mise à jour...
j'ai essayé de prendre en compte vos remarques au maximum, j'ai ajouté une méthode pour dépiler et puis d'autres détails j'men souviens plus !

et puis le Prog.C c'etait juste pour moi faire des tests,faites pas gaffe! ;-)

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
3011
Date d'inscription
jeudi 26 septembre 2002
Statut
Membre
Dernière intervention
27 novembre 2004
7
pour une question de clarté, c'est mieux de les definir en dehor de l'interface de la classe, mais c'est une question de gout

normalement le corps de la classe n'est que la meta-definition de la classe (la description en gros)
Messages postés
29
Date d'inscription
mercredi 14 janvier 2004
Statut
Membre
Dernière intervention
5 mars 2007

pourquoi est-ce que tu sors les inline?
Messages postés
3011
Date d'inscription
jeudi 26 septembre 2002
Statut
Membre
Dernière intervention
27 novembre 2004
7
ah, j'ai oublié de remplacer

// Affichages
int afficherPriorite(int i) const {return (_tab[i]._priorite);};
std::string afficherNom(int i) const {return (_tab[i]._nom);};

par

// Affichages
int afficherPriorite(int i) const;
std::string afficherNom(int i) const;
Messages postés
3011
Date d'inscription
jeudi 26 septembre 2002
Statut
Membre
Dernière intervention
27 novembre 2004
7
a mon gout le ..h devrait etre comme ca ;)

#ifndef ____PILE_H_____
#define ____PILE_H_____

#include
#include <string>

class Pile {

public:
struct element
{
std::string _nom ;
unsigned short _priorite;
};

// Constructeurs et destructeur
Pile();
Pile(int);
Pile(const Pile & tmp);
~Pile();

Pile & operator = (const Pile & tmp);
void viderPile();

// Affichages
int afficherPriorite(int i) const {return (_tab[i]._priorite);};
std::string afficherNom(int i) const {return (_tab[i]._nom);};
void afficherPile();
friend std::ostream & operator << (std::ostream & affichage,const Pile & pile);

void allongerPile();
void empiler(std::string chaine,int priorite);
void sauvegarder() const;
void charger();

private:
int _taille;
int _longueur;
element * _tab;
};

inline int Pile::afficherPriorite(int i) const
{
return (_tab[i]._priorite);
}

inline std::string Pile::afficherNom(int i) const
{
return (_tab[i]._nom);
}
#endif // ____PILE_H_____
Messages postés
29
Date d'inscription
mercredi 14 janvier 2004
Statut
Membre
Dernière intervention
5 mars 2007

donc dans le .C ça gene pas c'est ça?jvai regarder si j'en ai dans le .h tout de suite......
et jvai mettre a jour le code j'avais oublié de faire pas mal de trucs :-S
Afficher les 12 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.