Discussion :

[Luke spywoker]

Salut les C++,

J'écrit un programme faisant appel a une table de hachage

ou

std::unordered_multimap<uint8_t,SDL_Texture*>

Qui utilise la SDL2 comme vous le voyez.

Donc je stocke sous une même clefs une séquence de SDL_Texture*.

Et a la fin de stockage je ne sais si je dois re-haché la table car voici la sortie de mon programme:

Before rehashing
Fuuma -> for 317 elts
Fuuma -> bucket_count: 409
Fuuma -> load factor: 0.775061

After rehashing
Fuuma -> for 317 elts
Fuuma -> bucket_count: 337
Fuuma -> load factor: 0.940653

Before rehashing
Geese Howard -> for 297 elts
Geese Howard -> bucket_count: 409
Geese Howard -> load factor: 0.726161

After rehashing
Geese Howard -> for 297 elts
Geese Howard -> bucket_count: 313
Geese Howard -> load factor: 0.948882

Before rehashing
Hanzo -> for 324 elts
Hanzo -> bucket_count: 409
Hanzo -> load factor: 0.792176

After rehashing
Hanzo -> for 324 elts
Hanzo -> bucket_count: 337
Hanzo -> load factor: 0.961424

Before rehashing
Hotaru Futaba -> for 475 elts
Hotaru Futaba -> bucket_count: 823
Hotaru Futaba -> load factor: 0.577157

After rehashing
Hotaru Futaba -> for 475 elts
Hotaru Futaba -> bucket_count: 503
Hotaru Futaba -> load factor: 0.944334

Et je dois encore me taper 20-4 personnages...

Donc 375 éléments en moyenne approximativement pour 20 personnages:

Code :

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

1
2
 
375 * 20  = 7500

Donc y a sujet a réflection car je dois récupérer ces séquences dans une std::forward_list afin de me servir des séquences unitairement.

Personnellement j'aurai implémenter une table de hachage moi même basé sur des single-linked-list pouvant ainsi récupérer la liste que je veux.

Mais comment la STL enregistre mes données ???

Fait-je mieux de re-hacher la table ou pas ???

NOTE: Vous aurez compris ce que je veux:

Stocker mes pointeurs dans une table de hachage dont les valeurs sont stocker sous forme de single-linked-list en interne d'après des clefs qui donne directement accès aux listes de séquences d'images (ou des pointeurs) dont j'ai besoin SANS chercher dans toute la table de hachage afin de reconstituer toutes mes listes...

PS: Au passage: il n'y a pas de méthode directe pour récupérer le nombre de clefs dans une std::(unordered_)multimap ou je me trompe ?

Merci pour vos réponses éclairées illuminant les ténèbres de ignorance.

PS: Si vous n'avez pas compris je re-expliquerai et j'en dirai plus quand vous m'aurez répondus.

[Bousk]

Si tu veux récupérer tes machins sous forme de std::forward_list, pourquoi ne pas utiliser une std::unordered_map<uint8, std::list> ?
Perso je n'ai jamais utilisé de multimap, je vois pas bien l'intérêt, et si tu stockes des sprites, tu veux pouvoir récupérer un sprite en particulier normalement.

[ternel]

Je suis du même avis, d'autant qu'en général, on veut garder l'ordre des éléments d'une même clé.

[Luke spywoker]

Et bien moi aussi,

car après mon poste et une illumination divine

je stockes mes images qui sont des sprites mais sous forme d'images isolées se succédant, dans un conteneur:

Code :

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

1
2
3
 
 
std::unordered_map<int8_t, std::shared_ptr<std::forward_list<SDL_Texture*>>> conteneur  ;

Mais je change ma question: je met le smart pointer pour récupérer les séquences comme ceci:

Code :

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

1
2
3
4
5
 
 
std::shared_ptr<std::forward_list<SDL_Texture*>> get_sprite(const int8_t key) {
  return conteneur.at(key) ;
}

Ce qui me permet de détruire la séquence d'images extraite après l'avoir utilisé dans une boucle. Grâce a des (forward) iterators.

Mais est-ce vraiment la peine d'utiliser des pointeurs comme je le fait pour me débarrasser après usage ?

Comme cela:

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
 
 
int main(void) {
 
  // ...
 
  int8_t key{0} ;  
 
  while (true) {
 
    // ...
 
    auto ptr = get_sprite(key) ;
 
    auto iter = std::begin(*ptr) ;
 
    while ( iter != std::end(*ptr) ) {
 
        // Affichage de l'image grâce a: *iter
 
       ++iter ; 
    }
 
    ptr->reset() ;
 
    // Update et pause (FPS).
 
    ++key ; 
 }
 
 exit(EXIT_SUCCESS) ;
}

Pensez vous que je met en péril mon organisation en utilisant rehash(...) sur mon conteneur ?

J'aimerai aussi savoir aussi pourquoi il est conseiller d'utiliser systématiquement les fonctions std::begin(...) et std::end(...) de l'en tête <iterators> ?
Hypothèse: elles retournent l'iterator attendus par les algorithmes au lieu de celui de conteneur.begin() qui est celui par défaut du conteneur.

[ternel]

A priori, j'aurai plutôt fait une std::forward_list< std::shared_ptr<SDL_Texture> >Voire une std::forward_list< std::unique_ptr<SDL_Texture> >.

[Luke spywoker]

Et comment tu te débarrasse de la copie de la std::forward_list renvoyée.

L'on peut la réassigner simplement et l'ancienne instance disparait ?

Excusez mon ignorance mais je viens du C et du coup je suis très dynamique.

Et quand ma fonction renvoie une copie, alors que dans la doc il est écrit que la méthode std::forward_list.at(key) renvoye une référence, le pointeur SDL_Texture* est t il copié ?

PS: D'ailleurs ne serai-t-il pas mieux d'utiliser des raw-pointers pour des questions de performances au lieu d'un objet encapsulant un pointeur comme les smart-pointers ?

[bacelar]

Reposez vos questions après avoir relu la documentation sur les smart-pointers, vous verrez bien plus clair.

[Luke spywoker]

Merci !