Discussion :

[CptPingu]

Bonjour.

Je gal�re depuis un moment sur comment effacer un �l�ment sp�cifique d'un std::unordered_multimap. Je n'ai malheureusement trouv� ma r�ponse ni dans la documentation, ni sur le net. Je pr�cise que je travaille en C++0x.

Je m'explique: Dans un std::unordered_multimap, lorsque l'on a des collisions sur un index, celles-ci sont mises dans une liste associ�e � l'index (le bucket). Or j'ai bien trouv� une m�thode "erase" qui efface un index et le premier �l�ment du bucket, mais impossible de trouver comment supprimer un �l�ment choisi au sein de ce bucket.

J'ai �crit un exemple minimaliste, qui montre le probl�me auquel je suis confront�:

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
#include <iostream>
#include <unordered_map>
 
typedef std::unordered_multimap<uint32_t, std::string> hash_type;
 
namespace
{
  void
  eraseFromBucket(int key, hash_type& hash, const std::string& element)
  {
    auto bucket = hash.bucket(key);
    auto end = hash.cend(bucket);
    for (auto it = hash.cbegin(bucket); it != end; ++it)
    {
      if (it->second == element)
      {
	//hash.erase(it); // Je recherche une méthode qui supprime un élement d'un bucket !
	std::cout << "Dans le bucket " << it->first << ", supprimer l'element " << it->second << std::endl;
	return; // Return, iterators are now invalidated.
      }
    }
  }
 
  void
  display(const hash_type& hash)
  {
    auto end = hash.cend();
    for (auto it = hash.cbegin(); it != end; ++it)
      std::cout << it->first << " => " << it->second << std::endl;
  }
} // namespace
 
int main()
{
  hash_type hash;
 
  hash.insert(hash_type::value_type(1, "toto"));
  hash.insert(hash_type::value_type(2, "tutu"));
  hash.insert(hash_type::value_type(2, "tata"));
  hash.insert(hash_type::value_type(2, "titi"));
 
  std::cout << "Before" << std::endl;
  display(hash);
 
  eraseFromBucket(2, hash, "titi");
 
  std::cout << "After" << std::endl;
  display(hash);
 
  // auto it = hash.find(2);
  // hash.erase(it);
  // Supprimera le premier élément du bucket 2, "tutu"
 
  return 0;
}

Merci.

[CptPingu]

J'ai trouv� une solution, mais je doute fortement de sa propret�.
- Je recherche le premier �l�ment du bucket.
- Je recherche mon �l�ment au sein du bucket.
- Je prend la distance entre le d�but du bucket et l'�l�ment trouv�.
- J'avance l'iterator principal pour l'ajuster sur l'�l�ment trouv�.
- Je supprime l'�l�ment.

Ce qui donne:

auto find_iter = hash.find(key);
std::advance(find_iter, std::distance(hash.cbegin(bucket), it));

N'y aurait-il pas une meilleure solution ? Cette solution est-elle fiable ?

Le code modifi�:

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
#include <iostream>
#include <unordered_map>
#include <cassert>
 
typedef std::unordered_multimap<uint32_t, std::string> hash_type;
 
namespace
{
  void
  eraseFromBucket(int key, hash_type& hash, const std::string& element)
  {
    auto find_iter = hash.find(key);
    assert(find_iter != hash.end());
 
    auto bucket = hash.bucket(key);
    auto end = hash.cend(bucket);
    for (auto it = hash.cbegin(bucket); it != end; ++it)
    {
      if (it->second == element)
      {
	std::advance(find_iter, std::distance(hash.cbegin(bucket), it));
	std::cout << "Dans le bucket " << it->first << ", supprimer l'element " << it->second << std::endl;
	hash.erase(find_iter);
	return;
      }
    }
 
    assert(false);
  }
 
  void
  display(const hash_type& hash)
  {
    auto end = hash.cend();
    for (auto it = hash.cbegin(); it != end; ++it)
      std::cout << it->first << " => " << it->second << std::endl;
  }
} // namespace
 
int main()
{
  hash_type hash;
 
  hash.insert(hash_type::value_type(1, "toto"));
  hash.insert(hash_type::value_type(2, "tutu"));
  hash.insert(hash_type::value_type(2, "tata"));
  hash.insert(hash_type::value_type(2, "titi"));
 
  std::cout << "Before" << std::endl;
  display(hash);
 
  eraseFromBucket(2, hash, "titi");
 
  std::cout << "After" << std::endl;
  display(hash);
 
  return 0;
}

[dyslesia]

Bonjour,

ce qui me viendrais a l'esprit serait de parcourir le bucket en question, et de sauvegarder une copie de chaque �l�ment de ce bucket, except� l'�l�ment recherch�, et ensuite remplacer le bucket par le nouveau.
C'est certainement fiable mais pas tr�s propre

[CptPingu]

Merci dyslesia pour ta r�ponse.

N�anmoins, je pr�f�re tout de m�me utiliser la seconde m�thode que j'ai d�crite, puisqu'elle n'implique pas de copie, juste un iterateur suppl�mentaire.
Je reste int�ress�, par une m�thode permettant de supprimer directement un �l�ment d'un bucket, sans utiliser de hack.

[JolyLoic]

Je ne comprends pas ton probl�me... unordered_multimap poss�de une fonction erase prenant en param�tre un it�rateur.

[Arzar]

Bonjour,

CptPingu, je crois que tu fais une grosse confusion sur ce qu'est un "bucket" dans la terminologie des tables de hashage.

Un "bucket" ne contient pas du tout l'ensemble des �l�ments qui ont la m�me cl�.

Comme le dit Lo�c, pour effacer un �l�ment de la multimap il suffit d'utiliser la fonction membre erase() qui prendra en param�tre un iterateur pointant sur la paire cl�-valeur que tu veux supprimer.

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
 
#include <iostream>
#include <unordered_map>
#include <cassert>
#include <tuple>
#include <string>
 
 
typedef std::unordered_multimap<int, std::string> hash_type;
 
void eraseFromBucket(hash_type& hash, int key, const std::string& element)
{
  // equal_range permet de récupérer une paire d'itérateur représentant 
  // un intervalle des paires clé-élément ayant la même clé.
   hash_type::iterator firstSameKey, lastSameKey;
   std::tie(firstSameKey, lastSameKey) = hash.equal_range(key);
 
   // Puis on cherche dans cet intervalle la paire 
   // contenant l'élément voulu
   for(auto itFound = firstSameKey; itFound != lastSameKey; ++itFound )
   {
      if (itFound ->second == element)
      {
         // si on trouve la bonne paire, on l'efface
         hash.erase(itFound );
         return;
      }
   }
}
 
 
void display(const hash_type& hash)
{
   auto end = hash.cend();
   for (auto it = hash.cbegin(); it != end; ++it)
      std::cout << it->first << " => " << it->second << std::endl;
}
 
 
int main()
{
  hash_type hash;
 
  hash.insert(hash_type::value_type(1, "toto"));
  hash.insert(hash_type::value_type(2, "tutu"));
  hash.insert(hash_type::value_type(2, "tata"));
  hash.insert(hash_type::value_type(2, "titi"));
 
  std::cout << "Before" << std::endl;
  display(hash);
 
  eraseFromBucket(hash, 2, "titi");
 
  std::cout << "After" << std::endl;
  display(hash);
 
  return 0;
}

[CptPingu]

Je ne comprends pas ton probl�me... unordered_multimap poss�de une fonction erase prenant en param�tre un it�rateur.

Je pense avoir mal saisie l'utilisation de ce conteneur. N�anmoins, lorsque j'ai it�r� sur un sous ensemble, je me suis retrouv� avec un iterator incompatible avec erase (un const_local_iterator). D'o� mon interrogation (et mon hack bancal).

CptPingu, je crois que tu fais une grosse confusion sur ce qu'est un "bucket" dans la terminologie des tables de hashage.
Un "bucket" ne contient pas du tout l'ensemble des �l�ments qui ont la m�me cl�.

Je pense effectivement n'avoir pas compris la notion de bucket. Pourrais-tu m'expliquer cette notion, ou m'orienter vers une bonne documentation qui explique ce concept ? Comme dit dans mon premier post, je n'ai pas r�ussi � trouver une documentation explicative suffisante.

Si un bucket ne repr�sente pas la table de collision d'une cl�, alors � quoi servent:
- size_type bucket(const key_type& k) const;
- local_iterator begin(size_type n);

En tout cas, je te remercie pour la solution. J'avais l'intuition que ma solution n'�tait pas la bonne, mais je ne savais pas comment r�soudre mon probl�me.

[JolyLoic]

La table de collision d'une clef ne repr�sente pas tous les �l�ments ayant la m�me clef, mais tous les �l�ments ayant une clef poss�dant la m�me valeur de hash (en tenant compte du nombre actuel de buckets).

Si tu veux travailler avec tous les �l�ments ayant la m�me valeur de clef, la fonction membre equal_range te retourne une pair d'it�rateurs (des normaux, pas des local_iterators) repr�sentant ces �l�ments de m�me clef.

Si maintenant la notion de sous ensemble de m�me valeur de clef a beaucoup d'importance pour toi, plut�t qu'un multimap<key, value>, tu peux travailler avec un multimap<key, vector<value> >, m�me si �a demande un peu plus de soin quand tu enl�ve le dernier �l�ment d'un tel ensemble.

[Arzar]

Mea culpa, j'ai lu un peu vite tes messages CptPingu et en relisant plus calmement je pense que tu avais saisi.

Une unordered_map contient de nombreux "bucket" et chaque bucket est effectivement une sorte de container (souvent une liste chain�e) contenant l'ensemble des paires cl�-valeurs dont la cl� une fois pass� par la fonction de hachage donne le m�me index. Un bucket contient donc dans le cas d'une unordered_map toutes les paires cl�-valeurs qui rentrent en collision (m�me hash), mais dont les cl�s sont forcement diff�rentes alors que pour une unordered_multimap un bucket peut contenir des paires ayant la m�me cl�.

(Tes deux premiers codes ne semblent d'ailleurs pas g�rer la collision, � savoir qu'il peuvent effacer une paire cl�-valeur dont la valeur est identique (la string) mais dont la cl� n'est pas identique mais se trouve quand m�me pr�sent dans le bucket suite � une collision)

Ceci-dit en me replongeant un peu dans l'API d'unordered_map, c'est vrai que son design est quand m�me... assez sp�cial.

Mon impression, c'est qu'un plus de l'API classique d'un conteneur STL (iterator, begin, end, find, erase, insert etc.) on a une sorte de sous-API bien distincte uniquement d�di�e � la gestion des collisions :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
size_type bucket_count() const;
size_type max_bucket_count() const;
 
size_type bucket_size(size_type n) const;
size_type bucket(const key_type& k) const;
 
local_iterator       begin(size_type n);
local_iterator       end(size_type n);
const_local_iterator begin(size_type n) const;
const_local_iterator end(size_type n) const;
const_local_iterator cbegin(size_type n) const;
const_local_iterator cend(size_type n) const;

Mais j'avoue �tre stup�fait de ne pas trouver de moyen simple pour convertir un local_iterator en iterator. Cette sous-api ne semble d�di�e qu'� l'inspection de bucket et rien d'autre !

Je comprends tout � fait ton raisonnement :
1) On r�cup�re le num�ro du bucket
2) On parcours ce bucket jusqu'� trouver la paire qui nous int�resse
3) On efface la paire

Et tout semble marcher sur des roulettes jusqu'� ce que...

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
void eraseFromBucket(int key, hash_type& hash, const std::string& element)
{
   int bucket = hash.bucket(key);
   auto startBuck = hash.begin(bucket);
   auto endBuck = hash.end(bucket);
 
   for(auto it = startBuck ; it != endBuck  ; ++it)
   {
      if(it->first == key && it->second == element)
      {
      hash.erase(it); // BOUM
      return;
     }
  }
}

... l'on essaye de faire un erase avec un local_iterator alors que ce dernier ne prend que des iterator. (C'est d'autant plus vicieux que le code fonctionne avec visual studio car local_iterator n'est qu'un typedef d'iterator, mais pas avec les autres STL )

Et donc en fait pour que �a marche il faut refaire grosso-modo la m�me chose mais avec l'api classique STL ! (� coup de iterator, find ou equal_range, iterator) C'est quand m�me bizarrement fichu.

[JolyLoic]

Mon impression, c'est qu'un plus de l'API classique d'un conteneur STL (iterator, begin, end, find, erase, insert etc.) on a une sorte de sous-API bien distincte uniquement d�di�e � la gestion des collisions

On a effectivement une sous API d�di�e � la gestion fine des buckets. n1456 en donne un peu la motivation :

G. Bucket Interface

Like all standard containers, each of the hashed containers has member function begin() and end(). The range [c.begin(), c.end()) contains all of the elements in the container, presented as a flat range. Elements within a bucket are adjacent, but the iterator interface presents no information about where one bucket ends and the next begins.

It's also useful to expose the bucket structure, for two reasons. First, it lets users investigate how well their hash function performs: it lets them test how evenly elements are distributed within buckets, and to look at the elements within a bucket to see if they have any common properties. Second, if the iterators have an underlying segmented structure (as they do in existing singly linked list implementations), algorithms that exploit that structure, with an explicit nested loop, can be more efficient than algorithms that view the elements as a flat range.

The most important part of the bucket interface is an overloading of begin() and end(). If n is an integer, [begin(n), end(n)) is a range of iterators pointing to the elements in the nth bucket. These member functions return iterators, of course, but not of type X::iterator or X::const_iterator. Instead they return iterators of type X::local_iterator or X::const_local_iterator. A local iterator is able to iterate within a bucket, but not necessarily between buckets; in some implementations it's possible for X::local_iterator to be a simpler data structure than X::iterator. X::iterator and X::local_iterator are permitted to be the same type; implementations that use doubly linked lists will probably take advantage of that freedom.

It is likely that the bucket interface will change in the future. Other segmented containers may also want to define an interface that exposes the underlying segmentation, and greater experience with segmented containers may give us more insight into what a uniform interface should look like. We can't define a uniform interface for segmented containers until we've done it at least twice.

This bucket interface is not provided by the SGI, Dinkumware, or Metrowerks implementations. It is inspired partly by the Metrowerks collision-detection interface, and partly by earlier work (see [Austern 1998]) on algorithms for segmented containers.

Mon point de vue sur le sujet : En r�gle g�n�rale, ne pas l'utiliser dans du vrai code. Il s'agit avant tout d'un moyen de mettre en place une micro optimisation, ou encore de tester une fonction de hash. En outre, l�interface � base de equal_range est plus g�n�rique et marche aussi pour un multimap.

[CptPingu]

@Arzar: Merci beaucoup pour ton explication. C'est maintenant parfaitement clair pour moi. La collision d'�l�ments diff�rents qui donnent la m�me cl� de hash, est g�r�e indirectement. En effet, dans mon cas "element" est unique et discrimine un �l�ment (je parle de mon vrai code et non de mon exemple simplifi�).

@JolyLoic: Merci beaucoup � toi. J'ai bien lu l'extrait que tu as post�, et c'est tr�s int�ressant. Je serais curieux de savoir ou tu trouves ce genre d'informations pointues. J'aimerais approfondir ma connaissance sur ces nouveaux conteneurs (Scott Meyers ne les couvre pas dans son bouquin "Effective STL").

En r�sum�, je vais partir sur un unordered_multimap en utilisant equal_range.

[JolyLoic]

@JolyLoic: Merci beaucoup � toi. J'ai bien lu l'extrait que tu as post�, et c'est tr�s int�ressant. Je serais curieux de savoir ou tu trouves ce genre d'informations pointues. J'aimerais approfondir ma connaissance sur ces nouveaux conteneurs (Scott Meyers ne les couvre pas dans son bouquin "Effective STL").

Ce sont des documents de travail du comit� de normalisation du langage. Tous les documents techniques sont accessibles, apr�s il faut savoir s'y retrouver. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/

[CptPingu]

Merci pour le lien, je me le garde pr�cieusement.