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
| #include <fstream>
#include <string>
#include <vector>
#include <exception>
#include <boost/smart_ptr/shared_ptr.hpp>
#include <boost/smart_ptr/scoped_ptr.hpp>
class Enumerations
{
std::vector< std::string > m_villes;
public:
Enumerations()
{
std::ifstream fichierVilles("villes.txt");
if(fichierVilles)
{
std::string ligne;
while(std::getline(fichierVilles, ligne))
m_villes.push_back(ligne);
}
else
{
throw std::exception("Le fichier de villes ne peut être ouvert");
}
}
virtual ~Enumerations()
{
}
std::vector< std::string > const & getListVilles()
{
return m_villes;
}
};
class Personne
{
/**
* Seule la factory pourra créer des objets "Personne" grâce à l'amitié
* et à la limitation d'accès au constructeur
*/
Personne(boost::shared_ptr< Enumerations > donnees) : m_enums(donnees), m_ville(0)
{}
friend class PersonneFactory;
/**
* Objet de liste partagé
*/
boost::shared_ptr< Enumerations > m_enums;
/**
* On peut prendre un index grâce à deux hypothèses :
* - La liste de ville ne change pas au cours de l'exécution
* - Les objets personnes sont détruits à la fin et non persistants
*/
size_t m_ville;
public:
virtual ~Personne()
{}
void setVille(std::string const & ville)
{
std::vector<std::string> const & m_liste = m_enums -> getListVilles();
m_ville = std::find(m_liste.begin(), m_liste.end(), ville) - m_liste.begin();
}
std::string const & getVille()
{
return m_enums -> getListVilles()[m_ville];
}
};
class PersonneFactory
{
boost::shared_ptr< Enumerations > m_enums;
public:
PersonneFactory() : m_enums(new Enumerations)
{
}
Personne * CreerPersonne()
{
return new Personne(m_enums);
}
};
int main(int argc, char* argv[])
{
// On teste tout ce beau monde
PersonneFactory maFactory;
boost::scoped_ptr< Personne > personne1(maFactory.CreerPersonne());
boost::scoped_ptr< Personne > personne2(maFactory.CreerPersonne());
personne1 -> setVille("Marseille");
personne2 -> setVille("Azelot");
std::cout << "Ville de Personne 1 : " << personne1 -> getVille() << std::endl;
std::cout << "Ville de Personne 2 : " << personne2 -> getVille() << std::endl;
return 0;
} |
Comment bien gêrer des tables de données constantes
Répondre avec citation
.
Envoyé par gilims
) de créer une structure de donnée constante dans un header contenant mes informations. Je recopiais donc pour chaque personne les informations contenues dans la structure plutot que juste garder l'index dans l'objet "personne" et récupérer directement la valeur dans la structure de donnée.
. Typiquement, on va déléguer la gestion de la structure de donnée à un objet dédié. Si tu dois changer ta technique, il te suffira de modifier l'implémentation de cet objet sans avoir à repenser les autres.
. Je me suis juste mal exprimé
Partager