Discussion :

[MystEre]

Je souhaiterais savoir s'il existe en C++ une classe équivalente à la classe properties en Java. Cette dernière permet d'enregistrer et de charger une hashtable dans un fichier par exemple. S'il n'en existe pas : vais-je être obligée de recréer ma hastable en relisant le fichier ?

Dites moi si ça n'est pas très clair.

[Luc Hermitte]

Il y a des bibliothèques qui permettent de sérialiser des collections. Je ne sais pas si c'est ce que tu cherches.

[MystEre]

Je n'ai jamais utiliser les collections mais peut-être que cela pourra m'aider : pourrait tu me dire de quelles classes il s'agit ?

[Luc Hermitte]

En standard -> std::vector, std::list, std:multi_)set, std:multi_)map, std::stack, std::queue, std::deque

En non standard -> hash_table (généralement fourni avec la SL, mais ce n'est pas nécessaire, de plus il peut y avoir des variations entre un fournisseur et l'autre), boost::array, blitz::array, ....

Maintenant, avec des bibliothèques de sérialisation (comme p.ex. boost.serialization), il est possible de sauver et restaurer simplement leurs éléments. Pour les collections/conteneurs non standard, il peut (je n'ai pas vérifié) être nécessaire de rajouter un petit peu de code.

[MystEre]

Merci, je regarderais

[MystEre]

J'ai regarder map et hash_map mais je ne sais pas si ça correpond à ce que je veux : en fait je voudrais que ma clé soit constituée de 3 entiers. Une combinaison de 3 entiers serait unique et je souhaiterais lui attribuer comme valeur une chaîne de caractère. Est-ce que quelqu'un pourrait me dire s'il connaît une classe me permettant de faire cela ?

Merci

[Luc Hermitte]

Code non testé.

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
struct abc {
   int a; int b; int c;
   abc( int aa, int bb, int cc ) : a(aa), b(bb), c(cc) {}
};
 
// nécessaire pour les map, pour les hash_table, je ne sais pas
bool operator<(abc const & lhs, abc const & rhs)
{ 
    if      (lhs.a != rhs.a) return lhs.a < rhs.a;
    else if (lhs.b != rhs.b) return lhs.b < rhs.b;
    else return lhs.c < rhs.c;
}
 
....
typedef std::map< abc, std::string > type_table;
type_table table;
table[abc(1,2,3)] = "un deux trois";
 
type_table::const_iterator it = table.find(abc(1,2,3));
if (it != table.end()) 
    std::cout << "Trouvé: " << it->second << "\n";
else
    std::cout << "Rien trouvé!\n";

[rolkA]

Testé et çà fonctionne bien (à part l'accent aiguë à cause du mauvais encodage de mon fichier source 8) ) .

MystEre, comprends qu'un itérateur sur un map, comme 'it' ici, "pointe" sur une paire, type constitué entre autres des membres firstet second, first renvoyant la clé, et second la valeur stockée pour cette clé.

Dans le code ci-dessus, la clé est une structure et la valeur une chaîne, ce qui se traduit par la déclaration du map std::map< abc, std::string >, abc étant le type de structure défini pour stocker les 3 "clés" dont tu parlais. Et pour renvoyer un itérateur sur l'élément stocké à la clé "structure ayant les valeurs 1, 2, 3", tu utilise la méthode find du map, en lui passant la structure remplie avec les valeurs 1, 2, 3, ce que le code de Luc fait en une ligne grâce au constructeur défini dans la structure.

M'enfin... tout ceci paraphrase le code de Luc ...

A la place de find on aurait aussi pu utiliser l'opérateur crochet pour renvoyer directement la valeur associée à la clé, après avoir appelé la méthode count pour vérifier que la clé est bien présente dans le map:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
...
typedef std::map< abc, std::string > type_table;
type_table table;
table[abc(1,2,3)] = "un deux trois";
 
abc clef = abc(1,2,3);
if (table.count(clef) != 0)
    std::cout << "Trouvé: " << table[clef] << "\n";
else
    std::cout << "Rien trouvé!\n";
 
return 0;

Attention, l'opérateur crochet ne doit pas être utilisé pour lire la valeur associée à une clef si on n'est pas sûr que la clef existe. En effet, si la clef n'existe pas, elle est rajoutée au map ! (toujours vérifier avec count par exemple).

[Edit] ma méthode est uniquement documentaire

[Laurent Gomila]

[pinaillage]

Plutôt que d'utiliser map.count(cle) != 0 pour savoir si un élément existe, map.find(cle) != map.end() est plus "naturel". Et si l'élément existe bien on récupère directement un itérateur sur lui, ça évite un second parcours de la map plus tard pour y accéder.

[/pinaillage]

[MystEre]

Merci beaucoup pour ces réponses . C'est la première fois que je veux utiliser un conteneur associatif et je n'avais pas penser à ça .

Merci, merci !