Discussion :

[Muetdhiver]

Bonjour tout le monde, j'ai un souci purement technique.
Je créé une table de hachage dans une classe de gestion de dictionnaire, comme ceci :

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
 
class TDictionnary
{
 
 
			struct Key_Equality : public stdext::hash_compare< std::string >
			{
				bool operator()( const std::string& par_ro_string1, const std::string& par_ro_string2 )
				{
					return par_ro_string1 < par_ro_string2 ;
				}
			};
 
			struct Dictionnary
			{		
				unsigned long	ul_number ;
				std::string		o_def ;
 
			};
 
			typedef stdext::hash_map	< std::string, Dictionnary, Key_Equality >	HASH_MAP_DIC ;
			typedef std::pair			< std::string, Dictionnary >				HASH_MAP_ELT_DIC ;	
 
      public :	
 
          // mes fonctions etc.
 
	  private :    
 
		  // The stored dictionnary
		  HASH_MAP_DIC 		m_o_dictionnary ;
 
};

Tout se passe bien, pour résumer c'est donc une table indexée par des strings et contenant des structures (numéro, string).

Maintenant, dans mon parser, je veux simplement insérer un élément dans la table, avec :
loc_o_word : un mot parsé, de type std::string
loc_o_definition : une definition parsée, de type std::string.

Code :

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

1
2
3
4
5
6
 
// On crée l'element a inserer :
TDictionnary::Dictionnary loc_o_dictionnary_definition = { 0U, loc_o_definition } ;
 
// On insere :
loc_o_dictionnary.m_o_dictionnary.insert( TDictionnary::HASH_MAP_ELT_DIC( loc_o_word, loc_o_dictionnary_definition ) ) ;

Mais ca me lance une erreur de compil que je n'arrive pas à comprendre :

\programmation\visual studio 8\vc\include\xhash(314) error C2064: le terme ne correspond pas à une fonction qui prend 1 arguments
la classe ne définit pas un 'operator()' ou un opérateur de conversion défini par l'utilisateur en pointeur de fonction ou référence de fonction qui accepte le nombre d'arguments approprié

d:\programmation\visual studio 8\vc\include\xhash(298) : lors de la compilation de la fonction membre '<Inconnu>' de la classe <Inconnu>

Et en fait ca pète ici :
this->comp(this->_Kfn(*_Plist)) & _Mask;

de la fonction insert de xhash :

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
 
_Pairib insert(const value_type& _Val)
		{	// try to insert node with value _Val
		iterator _Plist, _Where;
		if (_Maxidx <= size() / bucket_size)
			{	// too dense, need to grow hash table
			if (_Vec.size() - 1 <= _Maxidx)
				{	// table full, double its size
				_Mask = ((_Vec.size() - 1) << 1) - 1;
				_Vec.resize(_Mask + 2, end());
				}
			else if (_Mask < _Maxidx)
				_Mask = (_Mask << 1) + 1;
 
			size_type _Bucket = _Maxidx - (_Mask >> 1) - 1;
			for (_Plist = _Vec[_Bucket]; _Plist != _Vec[_Bucket + 1]; )
				{	// split old bucket
				size_type _Newbucket =
					this->comp(this->_Kfn(*_Plist)) & _Mask;
				if (_Newbucket == _Bucket)
					++_Plist;	// leave element in old bucket

Merci d'avance pour toute aide, si quelqu'un à deja essayé d'insérer un objet qui ne soit pas un type natif dans une hash table.
Il manque un operator () à ma structure Dictionnary ?

Merci encore, a bientot.

Alexandre.

[Muetdhiver]

J'ai trouvé ! Voici la solution pour ceux qui auraient ce pb :

Il manquait une fonction retournant la clef de hachage dans mon Key_Compare... Voici la description de la fonction selon MSDN :

Hash function that is a unary predicate mapping key values of the elements to unsigned integers of type size_t

Donc avec cette clef de comparaison ca fonctionne :

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
 
struct Key_Equality : public stdext::hash_compare <std::string>
			{
				size_t operator() (const std::string& s) const
				{
					size_t h = 0;
					std::string::const_iterator p, p_end;
					for(p = s.begin(), p_end = s.end(); p != p_end; ++p)
					{
						h = 31 * h + (*p);
					}
					return h;
				}
 
				bool operator()( const std::string& par_ro_string1, const std::string& par_ro_string2 ) const
				{
					return par_ro_string1 < par_ro_string2 ;
				}
			};

Maintenant, est-ce que c'était utile de faire tout ca ?
MSDN a l'air de dire qu'il est possible d'omettre l'argument, remplacé par une clef par defaut (hash_compare<Key, less<Key> >).