Discussion :

[ealexdesign]

Bonjour je voudrai mettre à jour un composant que j'ai recoder en y intégrant la possibilité de sauvergarder une pile complète (pile + contenu), mais je n'y arrive pas.

voila mon composant de pile

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#include <fstream>
#include <iostream>
using namespace std;
#include "Pile.hpp"
 
/**
 * @brief Créer une pile vide
 * la pile est allouée en mémoire dynamique
 * elle est à désallouer (cf. detruire) en fin d’utilisation
 * @param[in,out] p : la pile à créer (vide)
 * @param[in] c : capacité de la pile (nb maximum d‘items stockés)
 * @pre aucune (la pile peut déjà être crée ou non)
 * @post p est vide  
 */
void creer(Pile& p, unsigned int c) {
	p.tab = new Item[c];
	p.sommet = -1;
	p.capacite = c;
}
 
/**
 * @brief Agrandir la pile
 * la pile est allouée en mémoire dynamique
 * elle est à désallouer (cf. detruire) en fin d’utilisation
 * @param[in,out] p : la pile à agrandir(pleine)
 * @param[in] c : capacité de la pile (nb maximum d‘items stockés)
 * @pre aucune (la pile doit etre pleine)
 * @post p est pleine  
 */
void agrandir(Pile & p, unsigned int c) {
	Item* newItem;
	p.capacite++;
	newItem = new Item[p.capacite];
 
	for(unsigned int i=0; i < p.capacite; i++) {
		newItem[i]= p.tab[i];
	}
 
	detruire(p);
	p.tab = newItem;
	p.capacite++;
 
}
/**
 * @brief Désallouer une pile
 * la pile a été créée (cf. creer)
 * @param[in,out] p : la pile concernée
 */
void detruire(Pile& p) {
	delete [] p.tab;
	p.tab = NULL;
}
 
/**
 * @brief Test de pile pleine
 * la pile a été créée (cf. creer)
 * @param[in] p : la pile testée
 * @return true si p est pleine, false sinon
 */
bool estPleine(const Pile& p) {
	return (p.sommet == (p.capacite-1));
}
 
/**
 * @brief Test de pile vide_ 
 * la pile a été créée (cf. creer)
 * @param[in] p : la pile testée
 * @return true si p est vide, false sinon
 */
bool estVide(const Pile& p) {
	return (p.sommet == -1);
}
 
/**
 * @brief Lire l'item au sommet de la pile_ * la pile a été créée (cf. creer)
 * @param[in] p : la pile concernée
 * @return la valeur de l'item au sommet de pile
 * @pre la pile n’est pas vide
 */
Item sommet(const Pile& p) {
	return p.tab[p.sommet];
}
 
/**
 * @brief Empiler un item sur la pile
 * la pile a été créée (cf. creer)
 * @param[in,out] p : la pile concernée
 * @param[in] it : l'item à empiler
 * @pre p n’est pas pleine
 * @post p n’est pas vide, it est le sommet de p
 */
void empiler(Pile& p, Item it) {
	if(!estPleine(p)) {
		agrandir(p, 1);
	}
	p.sommet++;
	p.tab[p.sommet] = it;
}
 
/**
 * @brief Dépiler l’item sommet de pile
 * la pile a été créée (cf. creer)
 * @param[in,out] p : la pile concernée
 * @pre p n’est pas vide
 */
void depiler(Pile& p) {
	assert(!estVide(p));
	p.sommet--;
}

et voila les deux nouvelle fonction que je voudrai intergrer pour sauvegarder mes piles dans des fichiers binaire.

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
/**
 * @brief sauvegarder les elements de la pile dans un fichier
 * @param[in,out] p : la pile concernée
 * @pre p est good
 */
void ecrireFB(ofstream& fe, const Pile& p) {
	if(!fe.fail()) {
		fe.write((char*)&p, sizeof(Pile));
	}
}
 
/**
 * @brief lecture des elements de la pile dans un fichier
 * @param[in,out] p : la pile concernée
 * @pre p est good
 */
void lireFB(ifstream& fl, Pile& p) {
	if(!fl.fail()) {
		fl.read((char*)&p, sizeof(p));
	}
	else {
		cout << "Le fichier est corompu." << endl;
		exit(1);
	}
}

pourriez vous m'indiquer comment m'y prendre pour faire une sauvegarde de mes pile dnas un fichier binaire, et pour ensuite leslire SVP

merci d'avance bonne journée

[Laurent Gomila]

Tu ne peux pas sauvegarder les données internes de ta pile de manière brute comme tu voudrais le faire. Tu aurais dans ton fichier quelques entiers dont un qui représente une adresse mémoire, ce qui ne t'aiderait pas beaucoup à recharger ta pile.

Il écrire les données de ta pile une à une dans le fichier, notamment parcourir ton tableau d'éléments et les sauvegarder un à un également.

PS : pourquoi une interface à base de fonctions libres alors que tu as une belle classe Pile ?

[Matthieu Brucher]

Parce que c'est mieux ainsi ? Et en plus, il pourrait même surcharger << et >> pour lire et écrire une pile à partir d'un flux

[ealexdesign]

si j'ai bien compris il faut je dépile et que je sauvegarde à chaque fois le sommet de la pile dans le fichier binaire?

sinon j'utilise mon propre composant pile car je suis étudiant et qu'ils nous ont simplement demandé de le recodé

[Médinoc]

Tu peux, mais sans "vraiment" dépiler (la sauvegarde ne doit pas modifier le vrai état de la pile).
Et attention lors du chargement à ne pas te tromper de sens: La pile chargée doit être dans le même état que la pile de départ, pas en sens inverse...

PS: Ton orthographe est déplorable et certaines fautes seraient repérées par un simple correcteur orthographique comme celui de Word..;