Besoin d aide

**DOC doc doc** · 11/12/2006, 08h54

J aurai besoin qu une ame charitable m aide afin de mener a bien ce projet.
Je dois livrer les fichiers qui sont indiqués...
Un bout de code serait le bienvenu
Merci d avance

Le thème général consiste à créer une classe "IntStack" pour gérer une structure classique :
la pile (LIFO), contenant ici des entiers. Les fonctions demandées pour cette classe sont celles de la
classe stack de la STL. Il s'agit ici d'un sujet d'école :
pas utiliser les fonctions de la classe stack standard.
II. La déclaration de la classe IntStack

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
class IntStack {
private :
vector<int> m_pile;
int m_index;
public:
// Constructeurs
//===============
// Constructeur sans arguments : pile vide
IntStack ();
// Constructeur de recopie
IntStack ( const IntStack &);
// Surcharge d'opérateurs
//=======================
// Opérateur d'affectation =
IntStack & operator = ( const IntStack & );
// Autres fonctions
//=================
// Hauteur (taille) de la pile (nbre d'élements)
int size() const;
// True si longueur = 0
bool empty () const;
// Renvoie l'élément au sommet de la pile (sans le dépiler)
int top() const;
// Dépile l'élément au sommet de la pile (sans en renvoyer la valeur)
void pop();
// Empile un élément au sommet de la pile
void push ( int );
};

Les deux membres « données » de cette classe sont :
o Le tableau dynamique m_pile, qui utilise la classe standard "vector".
La classe "vector" facilite grandement la programmation : vous n'avez en effet pas besoin de
gérer les allocations mémoire, car la classe "vector" le fait automatiquement et, de plus, elle
possède des fonctions prédéfinies qui permettent d'implémenter facilement les fonctions
demandées (cf. remarques en bas de la page 2).
o La taille de la pile, de type entier, m_index. Cette valeur correspond à l’indice du tableau qui
pointe au-dessus du dernier élément de la pile : quand la pile est vide, m_index vaut 0, si elle
contient 2 éléments, m_index vaut 2. m_index doit être décrémenté par pop() et incrémenté
par push().
III. Les fonctions membres de la classe IntStack
Les constructeurs
· Le constructeur sans arguments : il construit une pile "vide", de taille 0. Aucune initialisation n’est
nécessaire pour la variable membre m_pile.
· Le constructeur de recopie : il construit une pile en recopiant une pile déjà existante. N.B. : il n’y a
ici aucune allocation mémoire à faire.
La rédéfinition d’opérateurs
Le seul opérateur demandé est l'opérateur d'affectation (operator =). Il réalise l’affectation d’une pile à
partir d’une autre pile.
Les autres fonctions
Les autres fonctions demandées : size(), empty(), top(), pop(), push(), sont des fonctions classiques
des piles, le commentaire dans la déclaration présentée plus haut précisant ce qu’elles font.
IV. Le main()
Le main() sera dans un fichier à part. Il devra tester :
- La déclaration d’une pile vide,
- la construction d’une pile à partir d’une pile existante,
- l'empilement de quelques valeurs dans une pile,
- la lecture de la valeur du haut de la pile ( avec top() ), puis son dépilement ( avec pop() ), dans
une boucle qui dépile toutes les valeurs successivement.
- l'affectation d'une pile à une autre pile.
Les anomalies (ex : vouloir dépiler une pile vide) seront gérées à l’aide du mécanisme throw-try-catch.
V. Fichiers à livrer :
- IntStack.h
- IntStack.cpp ( pas obligatoire si vous définissez toutes les fonctions « inline »).
- main.cpp
- makefile

Remarques importantes :
Rappelons que de la classe standard "vector" réalise un tableau dynamique d’éléments de type
indiqué. Ex : vector<int> tab; déclare tab en tant que tableau d’entiers.
Voici quelques fonctions de la classe "vector" particulièrement utiles :
· size() : cette fonction, que vous avez déjà vue dans le TP4, renvoie la taille (=nombre d’éléments)
du tableau.
· push_back(valeur) : cette fonction, que vous avez aussi déjà vue dans le TP4, permet d’ajouter
valeur à la fin du tableau.
· pop_back() : cette fonction permet de supprimer le dernier élément du tableau.
· back() : cette fonction renvoie le dernier élément du tableau (sans le supprimer).

balise [code] rajoutée par r0d. Merci d'y penser la prochaine fois.

**Médinoc** · 11/12/2006, 09h22

Ben, c'est tout simple, c'est pratiquement juste un mapping de chaque fonction sur une fonction de std::vector...

Quelques remarques:

On est sur www.developpez.com et non pas www.onfaitvosdevoirs.com. Ici, tu postes ton codes et on t'aide à corriger tes erreurs. Mais on ne pondra pas du code pour toi, surtout un truc aussi simple.

**DOC doc doc** · 11/12/2006, 09h25

ok merci

**Médinoc** · 11/12/2006, 09h35

Tiens, je suis gentil:

Constructeur : tout simple
copie : copie
affectation: affectation
size() : size()
top() : back()
push() : push_back()
pop() : pop_back()

En fait, je ne vois même pas l'intéret pédagogique de ce genre d'exercice.
Ouéééé, on apprend à faire un wrapper... Et on ne nous dit même pas comment ça s'appelle...

**DOC doc doc** · 11/12/2006, 09h39

j t avoue ke je ne vois pas le but non plus
on nous explique pas grand chose et on nous demande de faire ça!!
mais merci beaucoup en tout cas

**Médinoc** · 11/12/2006, 09h44

Au fait, j'oubliais:
"besoin d'aide" est un trèèèès mauvais titre. Sois plus précis à l'avenir. Et n'oublie pas de cliquer sur

**DOC doc doc** · 11/12/2006, 10h56

j ai fait une partie du point cpp mais
je ne vois pas du tout comment faire le top, pop et push

voila le code deja tapé...s il y a quelques fautes...hesitez pas

#include "IntStack.h"
#include <stdexcpet>

//Constructeurs
//=============
//Constructeur à partir d une pile
IntStack::IntStack()
{
m_index=0;
}

//Constructeur de recopie
IntStack::IntStack (const IntStack & str)
{
m_pile=NULL;
strcpy (m_pile,str.m_pile);
}

//Surcharge d operateurs
//=======================
//Opérateur d affectation
IntStack & IntStack::operator = (const IntStack & str)
{
if (this == &str) return *this;

strcpy (m_pile, str.m_pile);
return *this;
}

// Autres fonctions
//=================
// Hauteur (taille) de la pile (nbre d'élements)
int IntStack::size() const
{
return m_pile;
}

// True si longueur = 0
bool IntStack::empty () const
{
if (m_index==0)
{
return true;
}
else
{
return false;
}
}

// Renvoie l'élément au sommet de la pile (sans le dépiler)
int IntStack::top() const;
{
back(

**olive_le_malin** · 11/12/2006, 11h33

au fait pourquoi utiliser un vector, et non pas un deque ??

std::stack est bâtie sur un deque par défaut, non ?

Code :

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

1
2
template<class T,
    class Cont = deque<T> >

@+

**Médinoc** · 11/12/2006, 11h39

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include "IntStack.h"
 
 
//Constructeurs
//=============
//Constructeur à partir d une pile
IntStack::IntStack(void)
 : m_index(0)
{
}
 
 
//Constructeur de recopie
IntStack::IntStack(const IntStack & src) : m_pile(src.m_pile), m_index(src.m_index)
{
}
 
//Surcharge d operateurs
//=======================
//Opérateur d affectation
IntStack & IntStack::operator = (const IntStack & src)
{
if (this == &src) return *this;
 
m_pile = src.m_pile;
m_index = src.m_index;
 
return *this;
}
 
// Autres fonctions
//=================
// Hauteur (taille) de la pile (nbre d'élements)
int IntStack::size(void) const
{
return m_index;
}
 
// True si longueur = 0
bool IntStack::empty(void) const
{
return (m_index==0);
}
 
// Renvoie l'élément au sommet de la pile (sans le dépiler)
int IntStack::top(void) const;
{
return m_pile.back();
}
 
void IntStack::push(int i)
{
m_pile.push_back(i);
++m_index;
}
 
void IntStack::pop(void)
{
if(m_index==0)
	{
	// traiter l'erreur en lançant une exception
	}
m_pile.pop_back();
--m_index;
}

**DOC doc doc** · 11/12/2006, 11h49

Un Grand Merci

**Luc Hermitte** · 11/12/2006, 23h22

Ici, grâce au vecteur sous-jacent, aucun intérêt de spécifier les 2 opérations de copie. Surtout pour avoir un opérateur d'affectaton qui repose sur un contre idiome, qui plus est utilisé là où il n'apporte rien.

m_index est redondant avec m_pile.size(), non ?

strcpy() n'a aucun rapport avec ce que tu cherches à faire. Cette fonction de la libc sert à copier des chaines 0-terminées. Or tu manipules des int qui sont dans vecteur... pas des chaines.

Besoin d aide

C++

Discussions similaires

Partager

Partager