Discussion :

[scary]

En effet très interessant

Sinon est-il correct que je mette le constructeur par copie et l'operateur= de cette façon:

Code :

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

1
2
3
4
Papier::Papier (const Papier& oldPapier)
{
	*this = oldPapier;
}

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
Papier& Papier::operator=(const Papier& p)
{
    if (this != &p) 
	{
		if (this->papierFinal != 0)
		{
			delete this->papierFinal;
		}
        *(this->papierFinal) = *(p.papierFinal);
		this->etatPapier = p.etatPapier;
	    this->typePapier = p.typePapier;
    }
 
    return *this;
}

[bruno_pages]

je pense que vous n'aviez pas vu ma dernière réponse (avant celle-ci)

[scary]

A oui en effet autant pour moi

Et bien en fait ma situation est la suivante. J'ai une classe Papier qui contient un type (tuto, article, court, long, recherche, ...), un état (soumis, accepte, refuse) et si et seulement si il est accepte on lui associe un autre papier qui represente le papier en format final.

J'espère avoir bien été clair

[bruno_pages]

ok, je trouve un peu bizarre la référence vers le "papier final" (c.a.d. que le papier n'évolue par en terme de contenu pour 'devenir' sa version finale) mais c'est pas grave, en tout cas ce sera bien supporté par Papier * papierFinal

type et états devraient être supportés par des énumérations plutôt que par des int

peut-on passer de l'état refusé à accepté, ou est-ce que la soumission ne peut être faite qu'une fois ?

A quoi sert d'avoir un constructeur sans argument car à priori dés le début le type est connu. De même je ne comprends pas Papier (TypePapier typePapier, EtatPapier etatPapier, Papier papierFinal). Au départ un papier est forcément dans l'état soumis et ne peut avoir de papierFinal associé, non ? si oui => un seul constructeur prenant seulement le type de papier donc Papier (TypePapier typePapier), et qui initialise l'état à soumis et papierFinal à 0

Est-il utile d'avoir un copy constructeur appelable, je veux dire dans quel cadre serait-il utile, et s'il l'est que devrait-il faire (au niveau sémantique) ?

même question au niveau de l'opérateur=

[scary]

ok, je trouve un peu bizarre la référence vers le "papier final" (c.a.d. que le papier n'évolue par en terme de contenu pour 'devenir' sa version finale) mais c'est pas grave, en tout cas ce sera bien supporté par Papier * papierFinal

C'est pour cela que j'ai fais ça mais seulement je n'avais aucune idée des soucis que ça allais endurer

type et états devraient être supportés par des énumérations plutôt que par des int

Ce sont des énumérations

peut-on passer de l'état refusé à accepté, ou est-ce que la soumission ne peut être faite qu'une fois ?

Non l'état du papier ne change qu'une seule fois quand il est à l'état soumis (valeur par défault).

A quoi sert d'avoir un constructeur sans argument car à priori dés le début le type est connu. De même je ne comprends pas Papier (TypePapier typePapier, EtatPapier etatPapier, Papier papierFinal). Au départ un papier est forcément dans l'état soumis et ne peut avoir de papierFinal associé, non ? si oui => un seul constructeur prenant seulement le type de papier donc Papier (TypePapier typePapier), et qui initialise l'état à soumis et papierFinal à 0

En effet autant pour moi

Est-il utile d'avoir un copy constructeur appelable, je veux dire dans quel cadre serait-il utile, et s'il l'est que devrait-il faire (au niveau sémantique) ?

même question au niveau de l'opérateur=

On sait jamais si un Papier un moment ou un autre aurait besoin d'être dupliquer.

[bruno_pages]

Ce sont des énumérations

désolé, je n'avais pas vérifié et j'ai confondu avec une autre discussion

Non l'état du papier ne change qu'une seule fois quand il est à l'état soumis (valeur par défault).

ok

est-ce que dans le cas ou le papier est rejeté il a quand même un etat final ?

On sait jamais si un Papier un moment ou un autre aurait besoin d'être dupliquer.

mais que veut précisément dire dupliquer ?

est-ce que vous voulez vraiment que l'état du papier initial change (attribut mis à jour) lorsqu'il est accepté ou refusé, ou est-ce qu'on crée une autre instance de Papier avec un lien entre le Papier initial et le final ?

ou est-ce qu'il ne serait pas plus simple d'avoir pour un Papier les contenus initiaux et finaux et donc au final qu'une unique instance de Papier sans cette histoire de référence vers le papier final ?

[scary]

désolé, je n'avais pas vérifié et j'ai confondu avec une autre discussion


ok

est-ce que dans le cas ou le papier est rejeté il a quand même un etat final ?

Non il a un etat final si et seulement si il a été accepté.

mais que veut précisément dire dupliquer ?

On fait un double d'un papier (genre on le photocopie).

est-ce que vous voulez vraiment que l'état du papier initial change (attribut mis à jour) lorsqu'il est accepté ou refusé, ou est-ce qu'on crée une autre instance de Papier avec un lien entre le Papier initial et le final ? ou est-ce qu'il ne serait pas plus simple d'avoir pour un Papier les contenus initiaux et finaux et donc au final qu'une unique instance de Papier sans cette histoire de référence vers le papier final ?

Et bien en fait c'est une bonne question puisque c'est une des questions que je me suis posé et dont je n'ai pas su répondre... C'est d'ailleurs pour cela que je me demande si je ne ferais pas mieux de créer une classe "PapierFinal" qui hérite de "Papier" et ainsi remplacer "Papier *papierFinal" par "PapierFinal *papierFinal", ne serait-ce pas mieux ?

[bruno_pages]

Non il a un etat final si et seulement si il a été accepté.

ok

On fait un double d'un papier (genre on le photocopie).

mais on n'est pas dans le monde réel, on peut avoir plusieurs références vers le même papier, il suffit de passer son adresse (Papier *)

créer une classe "PapierFinal"

cela fait bien compliqué, et surtout on gagne quoi ?

qui hérite de "Papier"

qu'apporterait cet héritage ?

qu'est-ce qui vous gène dans le fait d'avoir une instance unique pour un papier, quelque soit sont état ?
pourquoi d'une certaine façon faudrait-il conserver (au sens ne pas le perdre, y avoir toujours accès) le papier dans son état initial alors qu'il a été accepté ou refusé ?

[scary]

ok


mais on n'est pas dans le monde réel, on peut avoir plusieurs références vers le même papier, il suffit de passer son adresse (Papier *)


cela fait bien compliqué, et surtout on gagne quoi ?


qu'apporterait cet héritage ?

Rien je suis bien d'accords juste seulement un peu plus de lisibilité.

qu'est-ce qui vous gène dans le fait d'avoir une instance unique pour un papier, quelque soit sont état ?
pourquoi d'une certaine façon faudrait-il conserver (au sens ne pas le perdre, y avoir toujours accès) le papier dans son état initial alors qu'il a été accepté ou refusé ?

Et bien en fait je dois garder dans un vector tout les papiers soumis, dans un autres tout les papiers acceptés et encore dans un autre tout les refusés. Je dois donc avoir accès à tout ces papiers même si ils sont acceptés ou refusés.

C'est pour cela que je ne vois pas du tout comment implémenter ce genre de situation avec le Papier à l'état final

[bruno_pages]

Et bien en fait je dois garder dans un vector tout les papiers soumis, dans un autres tout les papiers acceptés et encore dans un autre tout les refusés. Je dois donc avoir accès à tout ces papiers même si ils sont acceptés ou refusés.

le problème c'est que vous ne me donnez pas des raisons sémantique mais implémentatoire

tout ce que je peux (re)dire c'est que je vois deux possibilités

1) soit il y a une seule instance pour un papier donné, quelque soit sont état, cela veut dire qu'initialement le papier est seulement référencé par le vecteur des soumis, puis il est ajouté dans celui des acceptés ou refusés, mais c'est le pointeur vers la même instance qui se retrouve dans deux vecteur. Dans cette solution un papier se transforme, si il y a un attribut qui donne l'état alors une fois accepté ou refusé le tableau des soumis pointe vers un papier dont l'état n'est plus 'soumis'

2) le fait qu'un papier soit accepté ou refusé provoque la création d'une nouvelle instance, d'une certaine façon il ne s'agit plus du même papier. Cependant vu le peu de différence entre l'état soumis et refuse (voir même accepte) je doute de l'intérêt reel de la chose

pour répondre il faut savoir ce que vous voulez faire avec ces Papiers, et moi je ne le sais pas, désolé

[scary]

En fait c'est un énoncé que je dois implémenter, tout ce que j'ai est l'énoncé suivant pour la classe Papier:

La classe "Papier"
Description: représente la notion de papier soumis ou accepté pour/par une conférence. Le pa pier peut être dans l'état soumisn accepté ou rejeté. A chaque papier accepté est associé un autre papier qui représente le papier en format initial de la conférence. Nous distinguons différents types de papiers court/long, recherche/industriel, tutorial, poster.

Attributs: Toutes les informations permettant de représenter un papier.

Méthodes:

• Consulter et metre à jour les attributs
• Affichage des informations concernant un papier
• Affichage de la liste des papiers soumis
• Affichage de la liste des papiers acceptés
• Affichage de la liste des papiers rejetés
• Affichage de la liste des papiers industriels
• Etc...

Voila et il faut que je me débrouille avec ceci Alors déjà que j'ai du mal à voir ou ils veulent en venir j'essai de faire avec ce que je connaist

[bruno_pages]

Bonjour,

ok alors là au moins c'est clair, il est explicitement dit dans l'énoncé que lorsqu'un papier est accepté il est différentié de son état initial.

donc on part d'un papier dans l'état 'soumis', puis

• s'il est refusé il passe dans l'état refusé, cela veut dire que la papier est modifié pour passer dans cet état, pas de nouvelle instance
• s'il est accepté un nouveau papier est crée représentant ce qu'il est dans l'état accepté, et le papier d'origine dans l'état soumis existe toujours

il est également explicitement dit que c'est la même classe qui représente un papier quelque soit sont état, donc pas de classe particulière pour un papier dans l'état final

notez que l'association ne va pas de papier initial vers papier accepté, mais l'inverse. Il y a deux façons d'associer deux papiers : soit l'association est faite au niveau du papier lui même avec un attribut dédié dans la classe comme vous l'aviez fait (sauf qu'il n'est pas papierFInal mais papierInitial), soit l'association est externe par exemple via une table d'association (une map, une alist etc) dont la clef est le papier dans son état final et la valeur le papier dans son état accepté. A vous de choisir

concernant les attributs d'un papier il y a son état, son type, peut être la référence du papier initial (suivant la façon d faire l'association) et je pense que vous deviez ajouter son contenu (string)parce que c'est quand même la raison d'être un papier

Consulter et metre à jour les attributs dit explicitement que vous devez avoir les getters/setter pour les attributs, ce qui revient à ce que vous aviez fait dés le début (sauf au niveau du détail). Personnellement je pense que c'est une erreur d'architecture car la classe papier devient ainsi une simple entité (une structure plutôt qu'une classe) dont l'implémentation (les attributs) est totalement visible de l'extérieur, mais bon, je ne sais pas à quel niveau de cours vous en êtes Ceci dit rien ne vous empêche de refuser certaine modifications, par exemple de passer d' accepté vers soumis, ou de créer le papier pour l'état accepté lorsque qu'on dit de passe de l'état soumis à accepté, mais dans ce cas il ne s'agit plus d'un simple setter. Si vous faites de simple setter je pense que vous deviez faire indiquer dans votre devoir que faire ainsi permet de faire des choses incompatible avec l'énoncé et que ce n'est donc pas une 'bonne' solution

Affichage des informations concernant un papier : vous devez faire une opération d'affichage

Affichage de la liste des papiers XXX : c'est ce pourquoi vous aviez vos trois vecteurs. Remarquer qu'il y a aussi afficher les papiers industriels etc, donc si vous continuez ainsi vous devez aussi avoir un vecteur dédié pour chaque type de papier ... et au final un tas de vecteurs. Ce n'est donc pas la bonne solution; et de toute façon vous n'en avez pas besoin, il vous suffit d'avoir la liste des tout les papiers (utilisez plutôt une liste qu'un vecteur car il est moins cher d'ajouter un nouvel élément dans une liste que dans un vecteur, puis de la parcourir en se demandant s'il est dans le type/état désiré. Il y a plusieurs façon de faire ces fonctions d'affichage, au sens ou suivant comment vous faites leur nombre varie, comme il y a de 'mauvaises' façon de faire faite donc une proposition et je vous dirai ce que j'en pense

[scary]

D'accords alors voila ce que j'ai fais:

le .h

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
/***********************************************************************
 * Module:  Papier.h
 * Author:  Scary
 * Modified: mardi 30 mars 2010 13:15:22
 * Purpose: Declaration of the class Papier
 ***********************************************************************/
 
#ifndef PAPIER_H
#define PAPIER_H
 
#include "TypePapier.h"
#include "EtatPapier.h"
 
#include <vector>
#include <string>
 
class Papier
{
	private:
		Papier *papierInitial;
		TypePapier::Type typePapier;
		EtatPapier::Etat etatPapier;
		std::vector<Papier> listeAccepte;
		std::vector<Papier> listeSoumis;
		std::vector<Papier> listeRefuse;
 
	public:
	    Papier (TypePapier::Type typePapier);
	    Papier (const Papier& oldPapier);
	    virtual ~Papier();
	    virtual TypePapier::Type getTypePapier (void) const;
	    virtual EtatPapier::Etat getEtatPapier (void) const;
	    virtual Papier getPapierInitial (void) const;
	    virtual void setPapierInitial (const Papier& newPapierInitial);
	    virtual void setTypePapier (TypePapier::Type newTypePapier);
	    virtual void setEtatPapier (EtatPapier::Etat newEtatPapier);
		virtual void affichage (std::ostream& os) const;
		virtual void affichageType (std::ostream& os, TypePapier::Type type) const;
		virtual void affichageEtat (std::ostream& os, EtatPapier::Etat etat) const;
		virtual void ajoutPapier (const Papier& papier);
		virtual Papier& operator=(const Papier& p);
};
 
inline std::ostream& operator<<(std::ostream& os, const Papier& p)
{
	p.affichage (os);
 
	return os;
}
 
#endif

et le .cpp

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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
/***********************************************************************
 * Module:  Papier.cpp
 * Author:  Scary
 * Modified: mardi 30 mars 2010 13:15:22
 * Purpose: Implementation of the class Papier
 ***********************************************************************/
 
#include "Papier.h"
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::Papier (TypePapier::Type typePapier)
// Purpose:    Implementation of Papier::Papier ()
// Parameters:
// - typePapier
////////////////////////////////////////////////////////////////////////
 
Papier::Papier (TypePapier::Type typePapier)
{
	this->typePapier = typePapier;
	this->etatPapier = EtatPapier::soumis;
	this->papierInitial = 0;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::Papier (const Papier& oldPapier)
// Purpose:    Implementation of Papier::Papier ()
// Parameters:
// - oldPapier     
////////////////////////////////////////////////////////////////////////
 
Papier::Papier (const Papier& oldPapier)
{
	*this = oldPapier;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::~Papier ()
// Purpose:    Implementation of Papier::~Papier ()    
////////////////////////////////////////////////////////////////////////
 
Papier::~Papier ()
{
	delete this->papierInitial;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::getTypePapier () const
// Purpose:    Implementation of Papier::getTypePapier ()
// Return:     TypePapier::Type
////////////////////////////////////////////////////////////////////////
 
TypePapier::Type Papier::getTypePapier (void) const
{
	return this->typePapier;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::getEtatPapier () const
// Purpose:    Implementation of Papier::getEtatPapier ()
// Return:     EtatPapier::Etat
////////////////////////////////////////////////////////////////////////
 
EtatPapier::Etat Papier::getEtatPapier (void) const
{
	return this->etatPapier;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::getPapierInitial () const
// Purpose:    Implementation of Papier::getPapierInitial ()
// Return:     Papier
////////////////////////////////////////////////////////////////////////
 
Papier Papier::getPapierInitial (void) const
{
   return *(this->papierInitial);
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::setPapierFinal (Papier newPapierFinal)
// Purpose:    Implementation of Papier::setPapierFinal ()
// Parameters:
// - newPapierFinal
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::setPapierInitial (const Papier& newPapierInitial)
{
   if (this->papierInitial != 0) 
   {
   		delete papierInitial;
   }
   *(this->papierInitial) = newPapierInitial;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::setTypePapier (TypePapier::Type newTypePapier)
// Purpose:    Implementation of Papier::setTypePapier ()
// Parameters:
// - newTypePapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::setTypePapier (TypePapier::Type newTypePapier)
{
	this->typePapier = newTypePapier;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::setEtatPapier (EtatPapier::Etat newEtatPapier)
// Purpose:    Implementation of Papier::setEtatPapier ()
// Parameters:
// - newEtatPapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::setEtatPapier (EtatPapier::Etat newEtatPapier)
{
	this->etatPapier = newEtatPapier;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::affichageEtat (std::ostream& os, EtatPapier::Etat etat) const
// Purpose:    Implementation of Papier::affichageEtat ()
// Parameters:
// - newEtatPapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::affichageEtat (std::ostream& os, EtatPapier::Etat etat) const
{
	if (etat == EtatPapier::accepte)
	{
		for (int i=0;i<this->listeAccepte.size ();i++)
		{
			os << this->listeAccepte.at (i) << " ";
		}
		os << std::endl;
	}
	else if (etat == EtatPapier::refuse)
	{
		for (int i=0;i<this->listeRefuse.size ();i++)
		{
			os << this->listeRefuse.at (i) << " ";
		}
		os << std::endl;
	}
	else
	{
		for (int i=0;i<this->listeSoumis.size ();i++)
		{
			os << this->listeSoumis.at (i) << " ";
		}
		os << std::endl;
	}
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::affichageType (std::ostream& os, TypePapier::Type type) const
// Purpose:    Implementation of Papier::affichageType ()
// Parameters:
// - newEtatPapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::affichageType (std::ostream& os, TypePapier::Type type) const
{
	for (int i=0;i<this->listeAccepte.size ();i++)
	{
		if (this->listeAccepte.at (i).typePapier == type)
		{
			os << this->listeAccepte.at (i) << " ";
		}
		os << std::endl;
	}
	for (int i=0;i<this->listeRefuse.size ();i++)
	{
		if (this->listeRefuse.at (i).typePapier == type)
		{
			os << this->listeRefuse.at (i) << " ";
		}
		os << std::endl;
	}
	for (int i=0;i<this->listeSoumis.size ();i++)
	{
		if (this->listeSoumis.at (i).typePapier == type)
		{
			os << this->listeSoumis.at (i) << " ";
		}
		os << std::endl;
	}
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::affichage (std::ostream& os) const
// Purpose:    Implementation of Papier::affichage ()
// Parameters:
// - newEtatPapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::affichage (std::ostream& os) const
{
	os << this->etatPapier << " " << this->typePapier << " ";
}
 
void Papier::ajoutPapier (const Papier& papier)
{
	if (papier.etatPapier == EtatPapier::accepte)
	{
		this->listeAccepte.push_back (papier);
	}
	else if (papier.etatPapier == EtatPapier::refuse)
	{
		this->listeRefuse.push_back (papier);
	}
	else
	{
		this->listeSoumis.push_back (papier);
	}
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::operator=(const Papier& p)
// Purpose:    Implementation of Papier::operator=()
// Parameters:
// - p
// Return:     Papier&
////////////////////////////////////////////////////////////////////////
 
Papier& Papier::operator=(const Papier& p)
{
    if (this != &p) 
	{
		if (this->papierInitial != 0)
		{
			delete this->papierInitial;
		}
        *(this->papierInitial) = *(p.papierInitial);
		this->etatPapier = p.etatPapier;
	    this->typePapier = p.typePapier;
    }
 
    return *this;
}

Par contre j'ai bien l'impression que le meme problème que précédemment ce pose non ?

[bruno_pages]

Bonsoir,

pourquoi TypePapier::Type et EtatPapier::Etat, les enums sont dans une classe ou un namespace ? pourquoi ne pas avoir simplement défini enums Type { ... }; et Enum Etat { Soumis, ... }; ?

généralement dans les enums on utilise une majuscule pour commencer le nom des items (Soumis ...), cela évite les homonymies avec les variables qui commencent par une minuscule. Mais c'est peut être pour éviter ces homonymies que vous avez utilisé des namespaces ?

vous ne voulez vraiment pas mettre un attribut contenu dans Papier ? vous ne voulez pas non plus leur mettre un titre ? drôle de 'papier' quand même ...

vous avez défini listeAccepte etc, malgré ce que j'avais dis, cela ne sert à rien, d'ailleurs en toute logique vous auriez du aussi avoir listPapersIndustriel etc. Il faut une seule liste contenant tous les papiers, ensuite en fonction de l'affichage demandé cela affiche que ceux qui correspondent.

ce qui ne va pas non plus c'est que vos listes sont des variables d'instance : cela veut dure que chaque papier contient ces listes, et donc qu'il y a 3*nombre-de-papiers listes ! et bien sur ces listes ne contiennent pas ce qu'il faut

il aurait fallut que ces trois listes soient des variables de classe (static) et non des variables d'instance. il faut donc une seule liste, appelons la Instances (commence pas une majuscule car attribut de classe et non d'instance), et celle-ci est bien sur une variable de classe

instance n'est pas une liste de Papier mais de pointeur sur Papier (Papier *), cela évitera des recopies lors de la mémorisation dans la liste et lors des accès, en plus cela évitera d'être lié à ce que fait le copy constructeur dont le rôle n'est pas clair (voir plus loin)

comme je l'avais aussi dit il vaut mieux utiliser une liste (list) plutôt qu'un vecteur (vector), car tout ajout/retrait dans le vecteur produit une réallocation de ce vecteur et sa recopie. Bien-sûr tout dépend cependant s'il y a plus d'ajout/retrait ou plus de parcours, pour le savoir il faudrait connaitre l'utilisation de la classe. De toute façon quelque soit le choix que vous prenez vous pouvez toujours mettre un commentaire parlant de cela.

papierInitial étant un pointeur vers un Papier il est préférable que getPapierInitial rende aussi un pointeur vers un Papier. De la même façon setPapierInitial rend en argument un Papier* et non une référence.

quand on défini un constructeur il est préférable d'initialiser les attributs en dehors du {}, dans votre cas cela ne change rien, mais dans d'autre cela évite une init avec valeur par défaut suivit d'une affectation. Il est également préférable que les paramètres ne portent pas le nom d'attribut, dans votre cas cela vous a obligé à écrire this-> ce qui est disgracieux, donc par exemple :

Code :

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

1
2
3
Papier::Papier (TypePapier::Type type)
    : typePapier(type), etatPapier(EtatPapier::soumis), papierInitial(0) {
}

attention, erreur classique dans le copy constructeur, vous faites *this = oldPapier et cela va mal se passer car papierInitial n'étant pas initialisé le test sur vous faites sur lui dans operator= équivaut à un lancé de dés, donc avant de faire *this = oldPapier faite papierInitial = 0. Le second problème comme j'en avais déjà parlé c'est qu'après oldPapier et this partageront le même papier initial, et donc cette même instance sera libérée autant de fois qu'elle a été partagée. L'intérêt et la sémantique du copy contructor et de l'affectation dans votre cas ne saute pas au yeux, si vous voulez vraiment avoir un copy constructor et affectation il faut que celui-ci recopie aussi le papier initial, comme cela plus de papier en état initial référencé par plusieurs papier en état accepté.

comme il faut mémoriser tout les papiers dans Instances il faut le faire dans les deux constructeurs, et ne pas supposer que cela est demandé par celui- qui fait les new alors que celui-ci ne sait même pas que les papier sont conservés dans une liste/vecteur. Une classe doit rendre des services cohérents, cacher ce qui est liée à son implémentation et ne pas demander aux autres de la connaitre plus que nécessaire

le destructeur de papier ne doit détruire le papierInitial que s'il est non nul, pas dans tout les cas. Cependant faut-il vraiment que le destruction d'un papier (accepté) provoque la destruction du papier version initiale ? quelque soit votre décision la dessus mettrez un commentaire disant que vous avez en toute connaissance de cause prisun choix et non que vous n'y avez pas pensé. Bien évidemment la destruction d'un papier le retire d'Instances

n'écrivez pas this->, c'est inutile car le compilateur connait les attributs, et cela rend l'écriture plus simple et donc plus facile à lire, donc par exemple :

Code :

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

1
2
3
4
TypePapier::Type Papier::getTypePapier (void) const
{
	return typePapier;
}

faites le changement partout

sauf pour setPapierInitial et getPapierInitial qui s'applique bien au papier initial, ne mettez pas Papier dans le nom des opérations de Papier, on se doute bien que les opérations de Papier sont faite pour Papier, donc getTypePapier devient getType etc

[IsetPapierInitial][/I] mets son argument (de type Papier *) dans papierInitial sans recopie en profondeur, car là vous avez l'erreur que j'avais déjà signalé à savoir modifier le papier que vous avez détruit à la ligne précédente. D'ailleurs, pourquoi n'aviez -vous pas déjà corrigé cela, est-ce que je ne suis pas clair ?
lorsque vous testez si papierInitial est non nul pour le libérer mettez un commentaire disant que ce cas n'est pas normal car un papier ne devrait pas recevoir un papier initial plusieurs fois. Dites aussi qu'associer un papierInitial ne devrait avoir de sens que si le papier est dans l'état accepter (encore une fois demander de définir ces setters n'a pas de sens et permet de rendre le système inconsistant )
donc en résumé :

Code :

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

1
2
3
4
5
6
7
8
9
10
void Papier::setPapierInitial (Papier * newPapierInitial)
{
   if (papierInitial != 0) 
   {
        // remark : it is very strange to modify the initial
      	// paper when it was already set
   	delete papierInitial;
   }
   papierInitial = newPapierInitial;
}

comme il n'y a plus qu'une unique liste d'instances (Instances) les opérations affichageEtat et affichageType deviennent plus simples

par contre utilisez des iterator plutôt que at, se sera plus élégant et beaucoup plus rapide dans le cas ou Instance est une liste et non un vecteur.

puisque vous avez défini une opération affichage pourquoi ne pas l'utiliser dans les opérations affichageXXX ?

l'opération ajoutPapier n'a pas besoin d'exister, l'allocation d'un papier le met dans Instance

operator= est donc a reprendre car il recopie aussi le papier Initial s'il est non nul

dernière remarque à creuser : si vous détruisez un papier dans l'état Soumis encore référencé par le papier dans l'état Accepte ce dernier pointe vers un élément détruit, il existe cependant de solutions pour éviter se problème

voila voila

[scary]

Bonsoir,

pourquoi TypePapier::Type et EtatPapier::Etat, les enums sont dans une classe ou un namespace ? pourquoi ne pas avoir simplement défini enums Type { ... }; et Enum Etat { Soumis, ... }; ?

généralement dans les enums on utilise une majuscule pour commencer le nom des items (Soumis ...), cela évite les homonymies avec les variables qui commencent par une minuscule. Mais c'est peut être pour éviter ces homonymies que vous avez utilisé des namespaces ?

Oui j'ai fais une classe contenant une enum dans ce but là.

vous ne voulez vraiment pas mettre un attribut contenu dans Papier ? vous ne voulez pas non plus leur mettre un titre ? drôle de 'papier' quand même ...

Oui c'est vrai c'est un oublie de ma part

vous avez défini listeAccepte etc, malgré ce que j'avais dis, cela ne sert à rien, d'ailleurs en toute logique vous auriez du aussi avoir listPapersIndustriel etc. Il faut une seule liste contenant tous les papiers, ensuite en fonction de l'affichage demandé cela affiche que ceux qui correspondent.

ce qui ne va pas non plus c'est que vos listes sont des variables d'instance : cela veut dure que chaque papier contient ces listes, et donc qu'il y a 3*nombre-de-papiers listes ! et bien sur ces listes ne contiennent pas ce qu'il faut

il aurait fallut que ces trois listes soient des variables de classe (static) et non des variables d'instance. il faut donc une seule liste, appelons la Instances (commence pas une majuscule car attribut de classe et non d'instance), et celle-ci est bien sur une variable de classe

instance n'est pas une liste de Papier mais de pointeur sur Papier (Papier *), cela évitera des recopies lors de la mémorisation dans la liste et lors des accès, en plus cela évitera d'être lié à ce que fait le copy constructeur dont le rôle n'est pas clair (voir plus loin)

En effet c'est une chose à laquelle je n'avais vraiment pas pensé mais à laquelle je remédie de suite

comme je l'avais aussi dit il vaut mieux utiliser une liste (list) plutôt qu'un vecteur (vector), car tout ajout/retrait dans le vecteur produit une réallocation de ce vecteur et sa recopie. Bien-sûr tout dépend cependant s'il y a plus d'ajout/retrait ou plus de parcours, pour le savoir il faudrait connaitre l'utilisation de la classe. De toute façon quelque soit le choix que vous prenez vous pouvez toujours mettre un commentaire parlant de cela.

Je suis obligé d'utiliser des vecteur pour les conteneurs (c'est spécifié au tout debut de mon énoncé) sauf pour certains cas qui sont indiqués au début de l'énoncé mais dont les papiers ne font pas parties donc => vecteur.

papierInitial étant un pointeur vers un Papier il est préférable que getPapierInitial rende aussi un pointeur vers un Papier. De la même façon setPapierInitial rend en argument un Papier* et non une référence.

J'effectue ces changements.

quand on défini un constructeur il est préférable d'initialiser les attributs en dehors du {}, dans votre cas cela ne change rien, mais dans d'autre cela évite une init avec valeur par défaut suivit d'une affectation. Il est également préférable que les paramètres ne portent pas le nom d'attribut, dans votre cas cela vous a obligé à écrire this-> ce qui est disgracieux, donc par exemple :

Code :

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

1
2
3
Papier::Papier (TypePapier::Type type)
    : typePapier(type), etatPapier(EtatPapier::soumis), papierInitial(0) {
}

Je programme à la base en Java et donc j'ai garder cet habitude de mettre toujours "this" devant un attribut ou une méthode de classe. Mais bon je vais modifier mon code en fonction

attention, erreur classique dans le copy constructeur, vous faites *this = oldPapier et cela va mal se passer car papierInitial n'étant pas initialisé le test sur vous faites sur lui dans operator= équivaut à un lancé de dés, donc avant de faire *this = oldPapier faite papierInitial = 0. Le second problème comme j'en avais déjà parlé c'est qu'après oldPapier et this partageront le même papier initial, et donc cette même instance sera libérée autant de fois qu'elle a été partagée. L'intérêt et la sémantique du copy contructor et de l'affectation dans votre cas ne saute pas au yeux, si vous voulez vraiment avoir un copy constructor et affectation il faut que celui-ci recopie aussi le papier initial, comme cela plus de papier en état initial référencé par plusieurs papier en état accepté.

Je retire donc le constructeur par copie et l'opérateur d'affectation.

comme il faut mémoriser tout les papiers dans Instances il faut le faire dans les deux constructeurs, et ne pas supposer que cela est demandé par celui- qui fait les new alors que celui-ci ne sait même pas que les papier sont conservés dans une liste/vecteur. Une classe doit rendre des services cohérents, cacher ce qui est liée à son implémentation et ne pas demander aux autres de la connaitre plus que nécessaire

C'est-à-dire, je ne vois pas trop ce que vous voulez dire
Il faut que je face un truc du genre:

Code :

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

Instances.push_back(*this);

??

le destructeur de papier ne doit détruire le papierInitial que s'il est non nul, pas dans tout les cas. Cependant faut-il vraiment que le destruction d'un papier (accepté) provoque la destruction du papier version initiale ? quelque soit votre décision la dessus mettrez un commentaire disant que vous avez en toute connaissance de cause prisun choix et non que vous n'y avez pas pensé. Bien évidemment la destruction d'un papier le retire d'Instances

Non en effet très bonne remarque, je retire donc le delete

n'écrivez pas this->, c'est inutile car le compilateur connait les attributs, et cela rend l'écriture plus simple et donc plus facile à lire, donc par exemple :

Code :

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

1
2
3
4
TypePapier::Type Papier::getTypePapier (void) const
{
	return typePapier;
}

faites le changement partout

Fait

sauf pour setPapierInitial et getPapierInitial qui s'applique bien au papier initial, ne mettez pas Papier dans le nom des opérations de Papier, on se doute bien que les opérations de Papier sont faite pour Papier, donc getTypePapier devient getType etc

Fait aussi

setPapierInitial mets son argument (de type Papier *) dans papierInitial sans recopie en profondeur, car là vous avez l'erreur que j'avais déjà signalé à savoir modifier le papier que vous avez détruit à la ligne précédente. D'ailleurs, pourquoi n'aviez -vous pas déjà corrigé cela, est-ce que je ne suis pas clair ?
lorsque vous testez si papierInitial est non nul pour le libérer mettez un commentaire disant que ce cas n'est pas normal car un papier ne devrait pas recevoir un papier initial plusieurs fois. Dites aussi qu'associer un papierInitial ne devrait avoir de sens que si le papier est dans l'état accepter (encore une fois demander de définir ces setters n'a pas de sens et permet de rendre le système inconsistant )
donc en résumé :

Code :

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

1
2
3
4
5
6
7
8
9
10
void Papier::setPapierInitial (Papier * newPapierInitial)
{
   if (papierInitial != 0) 
   {
        // remark : it is very strange to modify the initial
      	// paper when it was already set
   	delete papierInitial;
   }
   papierInitial = newPapierInitial;
}

Modification faite.

comme il n'y a plus qu'une unique liste d'instances (Instances) les opérations affichageEtat et affichageType deviennent plus simples

par contre utilisez des iterator plutôt que at, se sera plus élégant et beaucoup plus rapide dans le cas ou Instance est une liste et non un vecteur.

En effet, je fais le changement, mais pour les iterator vue que j'utilise un vecteur l'interet n'est pas excessif non ?

puisque vous avez défini une opération affichage pourquoi ne pas l'utiliser dans les opérations affichageXXX ?

La méthode "affichage" n'est utiliser que dans le .h lorsque je redéfinie l'opérateur "<<".

l'opération ajoutPapier n'a pas besoin d'exister, l'allocation d'un papier le met dans Instance

Vus que maintenant "Instance" contient des "Papier*" et plus des "Papier" oui en effet.

operator= est donc a reprendre car il recopie aussi le papier Initial s'il est non nul

dernière remarque à creuser : si vous détruisez un papier dans l'état Soumis encore référencé par le papier dans l'état Accepte ce dernier pointe vers un élément détruit, il existe cependant de solutions pour éviter se problème

voila voila

Vu que j'ai retirer la redéfinition de l'opérateur "=" il n'y a plus besoin de reprendre le code. Idem pour la remarque vue que je ne détruit plus le papier dans l'état soumis dans le destructeur.

Voici donc les codes modifiés:

le .h

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
/***********************************************************************
 * Module:  Papier.h
 * Author:  Scary
 * Modified: mardi 30 mars 2010 13:15:22
 * Purpose: Declaration of the class Papier
 ***********************************************************************/
 
#ifndef PAPIER_H
#define PAPIER_H
 
#include "TypePapier.h"
#include "EtatPapier.h"
 
#include <vector>
#include <string>
 
class Papier
{
	private:
		Papier *papierInitial;
		TypePapier::Type typePapier;
		EtatPapier::Etat etatPapier;
		static std::vector<Papier*> Instances;
		std::string contenu;
		std::string titre;
 
	public:
	    Papier (TypePapier::Type newType, std::string newTitre, std::string newContenu);
	    virtual ~Papier();
	    virtual TypePapier::Type getType (void) const;
	    virtual EtatPapier::Etat getEtat (void) const;
	    virtual Papier* getPapierInitial (void) const;
		virtual std::string getTitre (void) const;
		virtual std::string getContenu (void) const;
	    virtual void setPapierInitial (Papier* newPapierInitial);
	    virtual void setType (TypePapier::Type newType);
	    virtual void setEtat (EtatPapier::Etat newEtatPapier);
		virtual void setTitre (std::string newTitre);
		virtual void setContenu (std::string newContenu);
		virtual void affichage (std::ostream& os) const;
		virtual void affichageType (std::ostream& os, TypePapier::Type type) const;
		virtual void affichageEtat (std::ostream& os, EtatPapier::Etat etat) const;
};
 
inline std::ostream& operator<<(std::ostream& os, const Papier& p)
{
	p.affichage (os);
 
	return os;
}
 
#endif

et le .cpp

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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
/***********************************************************************
 * Module:  Papier.cpp
 * Author:  Scary
 * Modified: mardi 30 mars 2010 13:15:22
 * Purpose: Implementation of the class Papier
 ***********************************************************************/
 
#include "Papier.h"
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::Papier (TypePapier::Type typePapier)
// Purpose:    Implementation of Papier::Papier ()
// Parameters:
// - typePapier
////////////////////////////////////////////////////////////////////////
 
Papier::Papier (TypePapier::Type newType, std::string newTitre, std::string newContenu)
{
	typePapier = newType;
	etatPapier = EtatPapier::Soumis;
	papierInitial = 0;
	titre = newTitre;
	contenu = newContenu;
 
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::~Papier ()
// Purpose:    Implementation of Papier::~Papier ()    
////////////////////////////////////////////////////////////////////////
 
Papier::~Papier ()
{
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::getTypePapier () const
// Purpose:    Implementation of Papier::getTypePapier ()
// Return:     TypePapier::Type
////////////////////////////////////////////////////////////////////////
 
TypePapier::Type Papier::getType (void) const
{
	return typePapier;
}
 
std::string Papier::getTitre (void) const
{
	return titre;
}
 
std::string Papier::getContenu (void) const
{
	return contenu;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::getEtatPapier () const
// Purpose:    Implementation of Papier::getEtatPapier ()
// Return:     EtatPapier::Etat
////////////////////////////////////////////////////////////////////////
 
EtatPapier::Etat Papier::getEtat (void) const
{
	return etatPapier;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::getPapierInitial () const
// Purpose:    Implementation of Papier::getPapierInitial ()
// Return:     Papier
////////////////////////////////////////////////////////////////////////
 
Papier* Papier::getPapierInitial (void) const
{
   return papierInitial;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::setPapierFinal (Papier newPapierFinal)
// Purpose:    Implementation of Papier::setPapierFinal ()
// Parameters:
// - newPapierFinal
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::setPapierInitial (Papier* newPapierInitial)
{
   if (papierInitial != 0) 
   {
	   // Un papier initial ne peut etre affecte qu'une seule fois
	   // Associer un papier initial ne peut avoir de sens que si le papier est dans l'etat accepte
	   delete papierInitial;
   }
   this->papierInitial = newPapierInitial;
}
 
void Papier::setContenu (std::string newContenu)
{
	contenu = newContenu;
}
 
void Papier::setTitre (std::string newTitre)
{
	titre = newTitre;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::setTypePapier (TypePapier::Type newTypePapier)
// Purpose:    Implementation of Papier::setTypePapier ()
// Parameters:
// - newTypePapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::setType (TypePapier::Type newType)
{
	typePapier = newType;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::setEtatPapier (EtatPapier::Etat newEtatPapier)
// Purpose:    Implementation of Papier::setEtatPapier ()
// Parameters:
// - newEtatPapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::setEtat (EtatPapier::Etat newEtat)
{
	etatPapier = newEtat;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::affichageEtat (std::ostream& os, EtatPapier::Etat etat) const
// Purpose:    Implementation of Papier::affichageEtat ()
// Parameters:
// - newEtatPapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::affichageEtat (std::ostream& os, EtatPapier::Etat etat) const
{
	for (int i=0;i<Instances.size ();i++)
	{
		if (Instances.at (i)->etatPapier == etat)
		{
			os << Instances.at (i) << " ";
		}
		os << std::endl;
	}
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::affichageType (std::ostream& os, TypePapier::Type type) const
// Purpose:    Implementation of Papier::affichageType ()
// Parameters:
// - newEtatPapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::affichageType (std::ostream& os, TypePapier::Type type) const
{
	for (int i=0;i<Instances.size ();i++)
	{
		if (Instances.at (i)->typePapier == type)
		{
			os << Instances.at (i) << " ";
		}
		os << std::endl;
	}
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::affichage (std::ostream& os) const
// Purpose:    Implementation of Papier::affichage ()
// Parameters:
// - newEtatPapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::affichage (std::ostream& os) const
{
	os << etatPapier << " " << typePapier << " ";
}

Encore merci en tout cas pour votre aide

[bruno_pages]

Bonjour,

Oui j'ai fais une classe contenant une enum dans ce but là.

et bien utiliser une classe juste pour définir un espace de nom est une mauvaise idée (même si cela marche), dans ce cas utilisez un namespace. Mais encore une fois le mieux et le plus simple est tout simplement de ne pas le faire.

Je retire donc le constructeur par copie et l'opérateur d'affectation.

si vous ne faites rien le compilateur produira tout cela de lui même, et surtout pas avec la définition attendue.

donc deux solutions :

• les définir 'comme il faut'
• les déclarer private dans la classe et ne pas les définir afin qu'ils ne puissent pas être utilisés. Je m'explique, en les déclarant privés toute utilisation en dehors de la classe Papier produira une erreur de compilation, et en ne les définissant pas toute utilisation produira une erreur à l'édition de lien. Dans tout les cas le programme ne peut pas être produit s'il y a une utilisation de l'un d'eux. Par contre, pour lever toute ambiguïté et bien montrer que cela est fait exprès, il faut impérativement mettre leur définition en commentaire en disant pourquoi.

Code :

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

Instances.push_back(*this);

non, *this est un Papier, this est un Papier*, donc :

Code :

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

Instances.push_back(this);

et n'oubliez pas de l'ajouter dans le constructeur

pour les iterator vue que j'utilise un vecteur l'interet n'est pas excessif non ?

l'utilisation d'un itérateur est quand même plus propre

pourquoi toutes ces opérations déclarées virtuelle ?

dans le constructeur ne pas nommer les paramètres avec new dedans, ces paramètre sont les valeurs initiales pour le Papier, new fait penser à un changement

dans affichageXxx vous allez afficher plein de sauts de ligne pour rien. Ces opérations affichageXXX ne sont pas des opérations d'instance mais de classe

vous devriez appeller affichage les deux opérations en profitant du polymorphisme, le fait de spécifier un état ou un type permet de les distinguer

puisque vous avez défini une opération affichage pourquoi ne pas l'utiliser dans les opérations affichageXXX ?

La méthode "affichage" n'est utiliser que dans le .h lorsque je redéfinie l'opérateur "<<".

c'est bien là le problème car os << Instances.at (i) affichera l'adresse du Papier, je ne pense pas que c'est le but

il manque la définition d'Instance dans le .cpp

puisque vous avez ajoutez titre dans Papier l'affichage devrait l'afficher, ce sera quand même plus parlant à l'utilisation

os << etatPapier produira 0, 1 ou 2, pas la chaine de caractères "Soumis" ou autre, c'est à vous de faire ce passage

[scary]

Bonjour,


et bien utiliser une classe juste pour définir un espace de nom est une mauvaise idée (même si cela marche), dans ce cas utilisez un namespace. Mais encore une fois le mieux et le plus simple est tout simplement de ne pas le faire.

Changement effectué, j'ai juste mis une énum toute simple sans classe ni namespace.

si vous ne faites rien le compilateur produira tout cela de lui même, et surtout pas avec la définition attendue.

donc deux solutions :

• les définir 'comme il faut'
• les déclarer private dans la classe et ne pas les définir afin qu'ils ne puissent pas être utilisés. Je m'explique, en les déclarant privés toute utilisation en dehors de la classe Papier produira une erreur de compilation, et en ne les définissant pas toute utilisation produira une erreur à l'édition de lien. Dans tout les cas le programme ne peut pas être produit s'il y a une utilisation de l'un d'eux. Par contre, pour lever toute ambiguïté et bien montrer que cela est fait exprès, il faut impérativement mettre leur définition en commentaire en disant pourquoi.

J'ai opté pour la seconde solution, cela convient-il malgré tout ?

non, *this est un Papier, this est un Papier*, donc :

Code :

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

Instances.push_back(this);

et n'oubliez pas de l'ajouter dans le constructeur

Fait aussi

l'utilisation d'un itérateur est quand même plus propre

Fait.

pourquoi toutes ces opérations déclarées virtuelle ?

C'est demandé dans l'énoncé. Et en cours notre prof nous à conseiller de toujours mettre nos méthode à virtual (comme pour l'héritage) défois que l'on aurait besoin de faire du polymorphisme au moins cela sera déjà fait même si l'on en fait pas.

dans le constructeur ne pas nommer les paramètres avec new dedans, ces paramètre sont les valeurs initiales pour le Papier, new fait penser à un changement

Fait.

dans affichageXxx vous allez afficher plein de sauts de ligne pour rien. Ces opérations affichageXXX ne sont pas des opérations d'instance mais de classe

vous devriez appeller affichage les deux opérations en profitant du polymorphisme, le fait de spécifier un état ou un type permet de les distinguer

Fait.

c'est bien là le problème car os << Instances.at (i) affichera l'adresse du Papier, je ne pense pas que c'est le but

il manque la définition d'Instance dans le .cpp

Et comment je devrais faire cette définition d'instance, j'avoue ne pas savoir comment faire pour ce problème

puisque vous avez ajoutez titre dans Papier l'affichage devrait l'afficher, ce sera quand même plus parlant à l'utilisation

Fait.

os << etatPapier produira 0, 1 ou 2, pas la chaine de caractères "Soumis" ou autre, c'est à vous de faire ce passage

Fait aussi.

Voici donc le nouveau code:

le .h

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
/***********************************************************************
 * Module:  Papier.h
 * Author:  Scary
 * Modified: mardi 30 mars 2010 13:15:22
 * Purpose: Declaration of the class Papier
 ***********************************************************************/
 
#ifndef PAPIER_H
#define PAPIER_H
 
#include "TypePapier.h"
#include "EtatPapier.h"
 
#include <vector>
#include <string>
 
class Papier
{
	private:
		Papier *papierInitial;
		TypePapier typePapier;
		EtatPapier etatPapier;
		static std::vector<Papier*> Instances;
		std::string contenuPapier;
		std::string titrePapier;
		// en declarant prives le contructeur par copie et la surcharge de l'operateur affectation toute utilisation en dehors de 
		// la classe Papier produira une erreur de compilation, et en ne les definissant pas toute utilisation produira une 
		// erreur à l'edition de lien. Dans tout les cas le programme ne peut pas etre produit s'il y a une utilisation de l'un d'eux
		Papier (const Papier& papier);
		Papier& operator=(const Papier& p);
 
	public:
	    Papier (TypePapier newType, std::string newTitre, std::string newContenu);
	    virtual ~Papier();
	    virtual TypePapier getType (void) const;
	    virtual EtatPapier getEtat (void) const;
	    virtual Papier* getPapierInitial (void) const;
		virtual std::string getTitre (void) const;
		virtual std::string getContenu (void) const;
	    virtual void setPapierInitial (Papier* newPapierInitial);
	    virtual void setType (TypePapier newType);
	    virtual void setEtat (EtatPapier newEtatPapier);
		virtual void setTitre (std::string newTitre);
		virtual void setContenu (std::string newContenu);
		virtual void affichage (std::ostream& os) const;
		static void affichage (std::ostream& os, TypePapier type);
		static void affichage (std::ostream& os, EtatPapier etat);
};
 
inline std::ostream& operator<<(std::ostream& os, const Papier& p)
{
	p.affichage (os);
 
	return os;
}
 
#endif

le .cpp:

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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
/***********************************************************************
 * Module:  Papier.cpp
 * Author:  Scary
 * Modified: mardi 30 mars 2010 13:15:22
 * Purpose: Implementation of the class Papier
 ***********************************************************************/
 
#include "Papier.h"
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::Papier (TypePapier::Type typePapier)
// Purpose:    Implementation of Papier::Papier ()
// Parameters:
// - typePapier
////////////////////////////////////////////////////////////////////////
 
Papier::Papier (TypePapier type, std::string titre, std::string contenu) : typePapier (type), etatPapier (EtatPapier::Soumis),
	papierInitial (0), titrePapier (titre), contenuPapier (contenu)
{
	Instances.push_back (this);
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::~Papier ()
// Purpose:    Implementation of Papier::~Papier ()    
////////////////////////////////////////////////////////////////////////
 
Papier::~Papier ()
{
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::getTypePapier () const
// Purpose:    Implementation of Papier::getTypePapier ()
// Return:     TypePapier::Type
////////////////////////////////////////////////////////////////////////
 
TypePapier Papier::getType (void) const
{
	return typePapier;
}
 
std::string Papier::getTitre (void) const
{
	return titrePapier;
}
 
std::string Papier::getContenu (void) const
{
	return contenuPapier;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::getEtatPapier () const
// Purpose:    Implementation of Papier::getEtatPapier ()
// Return:     EtatPapier::Etat
////////////////////////////////////////////////////////////////////////
 
EtatPapier Papier::getEtat (void) const
{
	return etatPapier;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::getPapierInitial () const
// Purpose:    Implementation of Papier::getPapierInitial ()
// Return:     Papier
////////////////////////////////////////////////////////////////////////
 
Papier* Papier::getPapierInitial (void) const
{
   return papierInitial;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::setPapierFinal (Papier newPapierFinal)
// Purpose:    Implementation of Papier::setPapierFinal ()
// Parameters:
// - newPapierFinal
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::setPapierInitial (Papier* newPapierInitial)
{
   if (papierInitial != 0) 
   {
	   // Un papier initial ne peut etre affecte qu'une seule fois
	   // Associer un papier initial ne peut avoir de sens que si le papier est dans l'etat accepte
	   delete papierInitial;
   }
   papierInitial = newPapierInitial;
}
 
void Papier::setContenu (std::string newContenu)
{
	contenuPapier = newContenu;
}
 
void Papier::setTitre (std::string newTitre)
{
	titrePapier = newTitre;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::setTypePapier (TypePapier::Type newTypePapier)
// Purpose:    Implementation of Papier::setTypePapier ()
// Parameters:
// - newTypePapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::setType (TypePapier newType)
{
	typePapier = newType;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::setEtatPapier (EtatPapier::Etat newEtatPapier)
// Purpose:    Implementation of Papier::setEtatPapier ()
// Parameters:
// - newEtatPapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::setEtat (EtatPapier newEtat)
{
	etatPapier = newEtat;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::affichageEtat (std::ostream& os, EtatPapier::Etat etat) const
// Purpose:    Implementation of Papier::affichageEtat ()
// Parameters:
// - newEtatPapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::affichage (std::ostream& os, EtatPapier etat)
{
	for (std::vector<Papier*>::iterator it = Instances.begin ();it!=Instances.end ();it++)
	{
		if ((*it)->etatPapier == etat)
		{
			os << *it << " ";
		}
	}
	os << std::endl;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::affichageType (std::ostream& os, TypePapier::Type type) const
// Purpose:    Implementation of Papier::affichageType ()
// Parameters:
// - newEtatPapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::affichage (std::ostream& os, TypePapier type)
{
	for (std::vector<Papier*>::iterator it = Instances.begin ();it!=Instances.end ();it++)
	{
		if ((*it)->typePapier == type)
		{
			os << *it << " ";
		}
	}
	os << std::endl;
}
 
////////////////////////////////////////////////////////////////////////
// Name:       Papier::affichage (std::ostream& os) const
// Purpose:    Implementation of Papier::affichage ()
// Parameters:
// - newEtatPapier
// Return:     void
////////////////////////////////////////////////////////////////////////
 
void Papier::affichage (std::ostream& os) const
{
	if (etatPapier == EtatPapier::Accepte)
	{
		os << "Accepte ";
	}
	else if (etatPapier == EtatPapier::Refuse)
	{
		os << "Refuser ";
	}
	else
	{
		os << "Soumis ";
	}
	if (typePapier == TypePapier::Court)
	{
		os << "Court ";
	}
	else if (typePapier == TypePapier::Grand)
	{
		os << "Grand ";
	}
	else if (typePapier == TypePapier::Industriel)
	{
		os << "Industriel ";
	}
	else if (typePapier == TypePapier::Poster)
	{
		os << "Poster ";
	}
	else if (typePapier == TypePapier::Recherche)
	{
		os << "Recherche ";
	}
	else
	{
		os << "Tutoriel ";
	}
	os << titrePapier;
}

[bruno_pages]

J'ai opté pour la seconde solution, cela convient-il malgré tout ?

oui, en documentant bien la raison de la mise en commentaire des définitions, et étant près à parler de l'autre solution si besoin à l'oral ou même directement dans le commentaire

en cours notre prof nous à conseiller de toujours mettre nos méthode à virtual (comme pour l'héritage) défois que l'on aurait besoin de faire du polymorphisme au moins cela sera déjà fait même si l'on en fait pas.

vraiment ?

comment je devrais faire cette définition d'instance

dans le .ccp :

Code :

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

std::vector<Papier*> Papier::Instances;

on vous apprends quoi à l'école ?

peut être ajouter dans la définition du destructeur un commentaire disant que l'éventuel papierInitial n'est pas détruit lorsqu'un papier accepté l'est.
mettre à jour Instance pour qu'il ne contienne plus this

dans Papier::affichage utiliser des switch case plutôt que des if

ne pas mettre operator<< inline, le déclarer dans le .h et le définir dans le .cpp
pour info, généralement on met ce genre d'opérateur en friend dans la classe pour qu'ils puissent accéder aux membres privés, mais là c'est inutile à partir du moment ou il y a l'opération d'affichage

ne définissez pas Instances au milieu des autres attributs, mettre les attribut de classe et ceux d'instance dans deux groupes séparés rend la définition plus claire

ajouter un main provoquant quelques cas et exécuter la chose pour la tester

bon weekend

[scary]

Parfait tout marche nikel l'affichage, le papier version final tout

Encore merci pour cette aide bien précieuse