afficher une pile en POO

Peut être qu'un petit exemple te permettra de comprendre...

Je t'ai dit qu'il n'y a que peu de différence en C++ entre une structure et une classe.

Par facilité, je vais donc travailler avec le mot clé struct, mais le principe est exactement pareil avec le mot clé class, et j'écris le code de manière à ce que tu puisse le copier tel quel afin de le compiler et l'exécuter ;)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#include <iostream> using namespace std; // on en discutera plus tard ;) struct MaStruct { int a; void print() const { cout<<"C'est magique, a vaut "<<a<<endl; } }; int main() { /* créons une variable s de type MaStruct */ MaStruct s; /* définissons la valeur du membre a de la variable s à 5 */ s.a = 5; /* et demandons à s d'afficher cette valeur   * tu remarquera que je ne passe aucun argument à print ;)   */ s.print(); return 0; }

---

Au cas ou tu es l'habitude du C, en fait le pointeur this est passer implicitement pour chaque fonction membre. Ce pointeur est un pointeur vers la structure appelante (en considérant la syntaxe Appelante.methode()).

voici ce que me donne empiler

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

bool pile::empiler(int val)   { bool ok;   if(element->suivant==NULL) {   element->valeur=val; element->suivant=NULL; }   else { element->valeur=val; element->suivant=element; } return ok; }

---

Citation:

---

Envoyé par patricx

voici ce que me donne empiler

---

OUFFF... tu semble avoir compris le principe, mais la logique n'est absolument pas bonne...

La logique à suivre serait proche de

• créer un nouvel élément
• si la création échoue
  • renvoyer faux (l'insertion a échoué)
• assigner les valeurs "qui va bien" à l'élément créé
• si ce n'est pas le premier élément ajouté à la pile
  
  • relier l'élément créé au dernier de la pile
• l'élément créé devient le dernier de la pile
• renvoyer vrai (l'insertion s'est correctement déroulée)

Mais on approche :D

En principece code de vrait permettre d'empiler

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

bool pile::empiler(int val)   { bool ok=true;   if(element==NULL) {   element->valeur=val; element->suivant=NULL; }   else {structure *elem=new structure(); elem->valeur=val; elem->suivant=element; element=elem; } return ok; }

---

selement j'ai cette erreur lors de son execution

Voyons... Réfléchis un peu à ce que tu fais...

Citation:

---

Envoyé par patricx

En principece code de vrait permettre d'empiler

Code:

---

1 2 3 4 5

bool pile::empiler(int val)   { bool ok=true;

---

---

Jusque là, pas de problème...

Mais... ca se gate un peu après...

Citation:

---

Code:

---

1 2 3 4 5 6 7

if(element==NULL) {   element->valeur=val; element->suivant=NULL; }

---

---

Alors, si element vaut NULL (autrement dit, si element n'existe pas), tu demande que la variable valeur de element (qui n'existe pas) prenne val... 8O

Citation:

---

Code:

---

1 2 3 4 5 6

else {structure *elem=new structure(); elem->valeur=val; elem->suivant=element; element=elem; }

---

---

Sinon (autrement dit si element ne vaut pas NULL (si element existe):

• tu alloue la mémoire pour elem
• tu assigne la valeur val à la variable valeur de ce nouvel élément
• tu relie element à elem
• tu asigne elem à element.

Est ce que cela ressemble à la logique que je t'ai conseillée :question:

la deuxieme partie(else....) de mon code est insprirrée de tes conseils la première partie me sert à créer le premier élément de la pile ben je vois trop quel est le problème

Citation:

---

Envoyé par patricx

la deuxieme partie(else....) de mon code est insprirrée de tes conseils

---

Là, nous sommes bien d'accord,mais

Citation:

---

la première partie me sert à créer le premier élément de la pile ben je vois trop quel est le problème

---

Il y a deux problèmes...

Non seulement, tu ne crée pas un élément s'il n'en existe pas encore, mais, en plus, tu essaye de modifier le contenu (valeur et suivant) d'un objet qui... n'existe pas 8O

[EDIT]C'est bien pour cela, étant donné que tu dois de toutes manières créer un nouvel élément, qu'il y en ai déjà dans la pile ou non, que je te conseille de le créer... dés le départ ;)

ça me donne ce code

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

bool pile::empiler(int val)   { bool ok=true; structure *element=new structure(); element->valeur=val; element->suivant=NULL;   // else {structure *elem=new structure(); elem->valeur=val; elem->suivant=element; element=elem; } return ok; }

---

mon problème c'est comment ne pas revenier chaque fois sur le premier element

Attention...

Là, ce que tu fais, c'est...

1. Affecter à element (qui est le membre de ta classe) le résultat de la création d'un nouvel objet de type structure (en perdant donc la trace de l'objet qui existait précédemment et qui était affecté à element).
2. affecter les différentes valeurs au contenu de element
3. Affecter à une autre variable (elem) le résultat de la création d'un (autre) nouvel objet de type structure
4. affecter val à la variable valeur de ce nouvel élément
5. indiquer que ce qui suit elem est element (mais il s'agit du nouvel objet que l'on a créé en (1) )
6. affecter le dernier objet créé (elem) à element

Ce n'est, toujours pas ce qu'il faut faire :P

Citation:

---

mon problème c'est comment ne pas revenier chaque fois sur le premier element

---

Heuu... je ne suis pas sur decomprendre ta question...

Mais une chose est sure, il faut que tu respecte une logique stricte, et celle que je te propose est, décidément, la meilleure que l'on puisse envisager ;) :D

CE CODE ME CASSE LA TETE J L ABANDONE MERCIBIEN POUR TOUTE TON AIDE ET TA PATIENCE:oops::scarymov:

Ce qu'il faut, c'est que tu prenne conscience que tu dois respecter une logique stricte, et clairement définie...

Pour cela, tu dois réfléchir un temps soit peu à ce que tu fais.

Ainsi, pour quand même te donner la réponse, un simple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

bool Pile::empiler(int val) { /* créons un nouvel objet de type structure */ structure * temp=new structure; /* si la création échoue, on le signale */ if(!temp) return false; /* assignons la valeur correcte au contenu de ce nouvel objet */ temp->valeur = valeur; /* et relions le à l'objet qui est, pour l'instant, au sommet de la pile */ temp->suivant = element; /* il est temps de faire en sorte que le nouvel objet soit... au sommet   * de la pile   */ element = temp; /* et de signaler que tout s'est bien passé */ return true; }

---

agit exactement comme nous sommes en droit de l'espérer...

Mais, si tu suis une logique erronée, il ne faut pas t'étonner si tu n'arrive à rien ;)

Je ne le répéterai jamais assez, il ne sert à rien de se ruer sur le clavier et de commencer à "vomir" du code si l'on n'a pas, au minimum, une idée claire et précise des différentes étapes qu'il par lesquelles il faut passer ;)

Merci bien encore pour toute l'aide

ce code suscite en moi une question qui a toujours été mon probleme où se créé la queue de la pile (qui en est fait le tout premier element créé pour la pile )

en fait pour la queue on devrait avoir element->suivant=NULL

Le principe d'une pile, c'est que le premier élément inséré sera quoi qu'il arrive le dernier élément auquel tu aura accès.

C'est ce que l'on appelle un système LIFO(Last In, First Out... Premier entré, dernier sorti, si tu préfères en français)...

En effet, si tu empile des caisses, tu ne peux pas essayer d'accéder à la première que tu as placée avant d'avoir retiré toutes les autres, au risque de... toutes te les ramasser sur la tête ;)

c'est pour cela que tu dois faire en sorte de relier l'élément que tu veux rajouter à la pile au dernier élément de la pile, puis que tu dois définir cet élément comme étant... le dernier élément de la pile.

Le premier élément rajouté obtient la valeur NULL pour "l'élément suivant", ce qui indiquera qu'il n'y en a pas d'autre et... indiquera donc... qu'un a atteind la fin de la pile.

Mais peut être veux tu créer en réalité une file, un peu à l'instar de ce que l'on rencontre aux caisses des magasins, où le premier arrivé est le premier servi...

C'est alors un système FIFO (First In, First out... Premier entré, Premier sorti si tu préfère en français)

Dans ce cas, tu dois garder un pointeur sur le premier élément qui sera retiré et, *idéalement*, pour ne pas devoir parcourir l'ensemble des éléments lorsque tu veux en ajouter un, un pointeur sur le dernier élément rajouté...

Tu rajoute alors les éléments à un bout et tu les retire à l'autre...

ok merci bien
Je profite pour poser un autre probleme coomment calculer le sinus d'un angle(valeur(quelleest son unité) entrée au clavier)

Merci encore

Citation:

---

Envoyé par patricx

ok merci bien
Je profite pour poser un autre probleme coomment calculer le sinus d'un angle(valeur(quelleest son unité) entrée au clavier)

Merci encore

---

Sinus (et les autres, d'ailleurs) n'a pas d'unité propre.

Il est calculé sur base d'un angle généralement exprimé en radian.

Les fonctions sin, cos, tan, atan et toutes les autres sont déclarées, entres autres, dans le fichier d'en-tête <cmath>.

la surface d'un triangle est égal à la moitié du produit de deux cotés , le tout mutiplié par le produit de l'angle qu'ils forment
quand j'utilise cette instruction
surface=((longueur*largeur)/2)*sin(angle*M_PI/180);
je donne 180 à "angle" j'ai pas "0" comme valeur de la surface je comprend pas pourquoi

Peut être parce que la surface d'un triangle n'a rien à voir avec la sommes des angles de chacun de ses coté, vu que cette somme est, d'office, de 180° :P

Citation:

---

Envoyé par patricx

la surface d'un triangle est égal à la moitié du produit de deux cotés , le tout mutiplié par le produit de l'angle qu'ils forment
quand j'utilise cette instruction
surface=((longueur*largeur)/2)*sin(angle*M_PI/180);
je donne 180 à "angle" j'ai pas "0" comme valeur de la surface je comprend pas pourquoi

---

Bonjour,

Simplement parce que l'opérateur "/" effectue une division entière.
Je ne sais pas dans quel sens le compilo effectue ton opération dans ce cas vu que "/" et "*" ont la même priorité.
- Si "/" effectuée en 1er, M_PI/180 = 0 et donc angle*0 = 0. sin(0) = 1.
- Si "*" effectuée en 1er, M_PI*180 = 565,49 et donc 565/180 = 3. sin(3) != sin(M_PI).

Pour résoudre ton problème, écris :

Code:

---

surface=((longueur*largeur)/2.0)*sin(angle*M_PI/180.0);

---

au lieu de

Code:

---

surface=((longueur*largeur)/2)*sin(angle*M_PI/180);

---

Bon courage pour la suite.

@Koala01 :
Sa formule est juste ;), son texte explicatif est par contre faux.

Soit un triangle ABC,
l'aire d'un triangle est :
aire = (base*hauteur)/2
Avec base = AC
Hauteur = BC*sin(BCA)

Ce qui après remplacement nous donne :
aire = (AC*BC*sin(BCA))/2 <==> aire = ((AC*BC)/2)*sin(BCA)

c'est à dire la formule qu'à donné patricx :

Citation:

---

surface=((longueur*largeur)/2)*sin(angle*M_PI/180);

---

Mais mal retranscrite en français, cela devrait être :

Citation:

---

la surface d'un triangle est égal à la moitié du produit de deux cotés , le tout mutiplié par le produit (faux) sinus (vrai) de l'angle qu'ils forment

---

Ahhh la trigo et les maths...... :aie:

Citation:

---

Envoyé par patricx

la surface d'un triangle est égal à la moitié du produit de deux cotés , le tout mutiplié par le produit de l'angle qu'ils forment
quand j'utilise cette instruction
surface=((longueur*largeur)/2)*sin(angle*M_PI/180);
je donne 180 à "angle" j'ai pas "0" comme valeur de la surface je comprend pas pourquoi

---

Si ton valeur est très petit, proche à zéro (+ ou -), c'est parce que (angle*M_PI/180) n'est pas exactement égal à le numéro de radians en 180 degrés. C'est du "floating point" sur ordinateur, et ses resultats sont toujours approximatifs.