Classe pile dynamique

Télécharger le projet
Commenter

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! ;-)
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (cs_timinou)