Discussion :

[befalimpertinent]

Bonjour,
Je teste les unordered_set sous VS2010. Tout fonctionne parfaitement avec les type de base mais je n'arrive pas à les utiliser sur des types perso de type:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
class myB
{
public:
  string ch;
  myB(const string& s):ch(s){}
};
void main() 
{
   unordered_set<myB> a_hash;
   a_hash.insert(myB("Hello"));
}

Normal me direz vous car comment le compilo peut il savoir comment comparer et hasher myB. Certes.
Je vais pas tout mettre ici mais j'ai essayé plusieurs choses :
operator(), operator ==, fonctor dans la déclaration. Rien n'a compilé !

Impossible de trouver de la doc sur le net, tous les exemples que je trouve sont fait avec des types de bases : char, string, int.
Quelqu'un a des liens à me communiquer (ou une solution à mon problème) ? Merci

[3DArchi]

Salut,
void main :

Il te faut définir soit :
-> un opérateur== pour myB
-> une spécialisation de std::equal_to pour myB
-> définir ton propre foncteur avec bool operator()(const T& x, const T& y) const; et le préciser comme Prédicat dans la définition de ta variable

Plus, il faut définir :
-> une spécialisation de std::hash pour myB
-> définir ton propre foncteur avec result_type operator()(argument_type const&key_)const et le préciser comme hash dans la définition de ta variable

// spécialisations :

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
#include <unordered_set>
#include <string>
#include <functional>
 
class myB
{
public:
  std::string ch;
  myB(const std::string& s):ch(s){}
};
 
namespace std
{
    template<>
    class hash<myB>
    {
    public:
        typedef size_t result_type;
        typedef myB argument_type;
 
        result_type operator()(argument_type const&key_)const
        {
           return /* ce que tu veux. La seule contrainte (k==i)=>(h(k)==h(i))*/0;
        }
    };
 
    template<>
    class equal_to<myB>
    {
        public:
      bool operator()(const myB& rhs_, const myB& lhs_) const
      { return /* ce que tu veux */ true; }
    };
}
 
int main()
{
   std::unordered_set<myB> a_hash;
   a_hash.insert(myB("Hello"));
 
   return 0;
}

// operateur ==

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
#include <unordered_set>
#include <string>
#include <functional>
 
class myB
{
public:
  std::string ch;
  myB(const std::string& s):ch(s){}
};
bool operator==(myB const&, myB const&)
{
    return true;
}
 
namespace std
{
    template<>
    class hash<myB>
    {
    public:
        typedef size_t result_type;
        typedef myB argument_type;
 
        result_type operator()(argument_type const&key_)const
        {
           return /* ce que tu veux. La seule contrainte (k==i)=>(h(k)==h(i))*/0;
        }
    };
}
 
int main()
{
   std::unordered_set<myB> a_hash;
   a_hash.insert(myB("Hello"));
 
   return 0;
}

// foncteur :

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
#include <unordered_set>
#include <string>
 
class myB
{
public:
  std::string ch;
  myB(const std::string& s):ch(s){}
};
 
class my_hashfor_myB
{
public:
   typedef size_t result_type;
   typedef myB argument_type;
 
   result_type operator()(argument_type const&key_)const
   {
      return /* ce que tu veux. La seule contrainte (k==i)=>(h(k)==h(i))*/0;
   }
};
 
class my_equal_to_for_myB
{
   public:
   bool operator()(const myB& rhs_, const myB& lhs_) const
      { return /* ce que tu veux */ true; }
};
 
int main()
{
   std::unordered_set<myB,my_hashfor_myB,my_equal_to_for_myB> a_hash;
   a_hash.insert(myB("Hello"));
 
   return 0;
}

[befalimpertinent]

Merci, je sais pas trop ce que j'avais loupé au niveau des foncteurs mais maintenant c'est ok.
Au passage je n'avais jamais pensé à la spécialisation du template pour gérer ce genre de cas. Par contre je suis pas sur que cela soit une bonne idée de le mettre dans le namespace std