Problème hash_map pointeurs

Version imprimable

Bonjour à tous,

Je viens ici car depuis une semaine environ je bute sur un problème que je n'arrive pas à résoudre.

Je dois utiliser la classe hash_map mais dont les paramètres templates sont des pointeurs. Lorsque j'utilise l'opérateur[], je me fais insulter par le compilateur qui refuse les pointeurs (enfin je crois).

Voici le code:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 int main(int argc, char *argv[]) { hash<char*,int*> tab; char c; tab[&c]; } template <typename K, typename T> class hash : __gnu_cxx::hash_map<K*,T*> { public: T* operator[] (K k) { this->__gnu_cxx::hash_map<K*,T*>::operator[](k); } };
Je reçois le message suivant:
Code:

1 2 3 no matching function for call to `hash<char*, int*>::operator[](char*&)' candidates are: _Tp& __gnu_cxx::hash_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc>::operator[](const typename __gnu_cxx::hashtable<std::pair<const _Key, _Tp>, _Key, _HashFcn, std::_Select1st<std::pair<const _Key, _Tp> >, _EqualKey, _Alloc>::key_type&) [with _Key = char**, _Tp = int**, _HashFcn = __gnu_cxx::hash<char**>, _EqualKey = std::equal_to<char**>, _Alloc = std::allocator<int**>]
J'ai essayé des tas de combinaisons différentes, la seule qui fonctionne est de déclarer ma classe ainsi :class hash : __gnu_cxx::hash_map<K,T>
Le problème est que je ne peux pas faire cela car je dois remplacer une lib dans un programme en étant complètement transparent. Ce programme utilisait un STL payante qui utilisait des hash_map avec des paramètres template à pointeurs. Je reçois d'autres messages d'erreurs similaires lorsque j'utilise des itérateurs (pas d'opérateur=, pas d'opérateur!=, ...).

Je suis complètement perdu, plus j'essaye et plus j'ai l'impression de faire n'importe quoi.... Quelqu'un de fort en c++ pourrait-il m'aider?

Merci beaucoup!

20/04/2011, 16h03
screetch

Code:

__gnu_cxx::hash_map<K*,T*>

tu declare la in hash map sur K* et K est deja un char*
donc tu te retrouves avec un char**

Tout d'abord merci d'avoir répondu.

Si je comprends bien, le fait d'hériter comme cela:

class hash : __gnu_cxx::hash_map<K*,T*>

fait qu'automatiquement, la classe va enregistrer des pointeurs? (j'ai un peu de mal avec cette syntaxe nouvelle pour moi).

Sinon je ne peux pas déclarer les classes comme je veux, je ne peux pas faire:
hash<char,int> tab;

car ce n'est pas moi qui les déclare, je ne fait que mettre à jour un programme déjà existant :( J'ai voulu essayer ta méthode mais je n'ai pas pu:(

Autrement, j'ai réfléchi et cet après-midi j'ai trouvé la lumière:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 template <typename K , typename T > class tabHach { typedef unsigned long int add; //taille d'une adresse sur un PC 32 bits private: __gnu_cxx::hash_map <add, add> tableau; public: T*& operator[] (K* k) { return (T*&)tableau.operator[]((add)k); } };
Je n'hérite plus de hash_map mais j'en possède une en tant qu'attribut avec pour paramètre des entiers de la taille de mes adresses et je caste lorsqu'il faut pour retourner les bonnes valeurs!!

Tout a l'air de fonctionner mais crois-tu que c'est une bonne idée? A mon travail, personne n'est spécialiste du c++ alors je n'ai pas vraiment de retour...

En tous cas, merci beaucoup pour ton aide.

20/04/2011, 19h16
screetch

Oj oj oj non c'est pas une bonne idée!

Déjà je ne comprends pas pourquoi tu as besoin d'un hash spécial pour avoir un hash de pointeurs.
Un template (un hash map par exemple) prenant en argument un K, le K en question peut très bien être un pointeur.
K peut être int, char, une classe, un float, une référence, un pointeur sur un int etc etc.
Je ne comprends pas l'utilité de ta classe hash.

"Déjà je ne comprends pas pourquoi tu as besoin d'un hash spécial pour avoir un hash de pointeurs"

C'est ce que je croyais au début!
Code:

1 2 3 4 5 char a = 0x41; int i = 1; __gnu_cxx::hash_map<char*,int*> tab; tab.insert(&a,&i);
Code:

1 2 3 no matching function for call to `__gnu_cxx::hash_map<char*, int*, __gnu_cxx::hash<char*>, std::equal_to<char*>, std::allocator<int*> >::insert(char*, int*)' candidates are: std::pair<typename __gnu_cxx::hashtable<std::pair<const _Key, _Tp>, _Key, _HashFcn, std::_Select1st<std::pair<const _Key, _Tp> >, _EqualKey, _Alloc>::iterator, bool> __gnu_cxx::hash_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc>::insert(const typename __gnu_cxx::hashtable<std::pair<const _Key, _Tp>, _Key, _HashFcn, std::_Select1st<std::pair<const _Key, _Tp> >, _EqualKey, _Alloc>::value_type&) [with _Key = char*, _Tp = int*, _HashFcn = __gnu_cxx::hash<char*>, _EqualKey = std::equal_to<char*>, _Alloc = std::allocator<int*>]
Donc la hash_map standard a l'air de n'accepter aucun pointeur (à mois que je fasse une erreur dans l'écriture).

D'autre part, j'ai toujours ce souci de compatibilité avec le code existant qui considérait que ma hash_map prenait des pointeurs. Il se trouve que la bibliothèque que je dois remplacer est l'extension STL de chez Roguewave. Je ne peux pas te donner le code car il est propriétaire mais en voilà un petit bout:
Code:

1 2 3 4 5 6 template <class K, class T, class H, class EQ> class RWTPtrHashMap : private RW_PMapAssoc<rw_hashmap<K*,T*,rw_deref_hash<H,K>, rw_deref_compare<EQ,K>,RW_SL_STD(allocator)<K*> >, RWTPtrHashMap<K,T,H,EQ>, K, T>
Le code est trop compliqué pour que je comprenne comment ils ont fait alors j'ai du trouver seul les solutions.

Autrement, je comprends que typecaster des pointeurs en entiers 32 bits est dangereux si l'on ne sait pas ce qu'on fait, en plus d'être ultra incompatible avec les machines 64 bits. Mais pourquoi est-ce une mauvaise idée?

Ça fait plaisir de parler avec un vrai pro du c++ :ccool:

21/04/2011, 16h54
Goten

Pourquoi tu utilises une feature interne du compilateur? T'es même pas garanti de la stabilité du truc!
21/04/2011, 17h31
screetch
insert n'attend pas un pointeur sur un char et un pointeur sur un int, il attend une paire dont la première valeur est un pointeur sur char et la deuxième un pointeur sur int:
Code:

1 2 3 4 char a = 0x41; int i = 1; __gnu_cxx::hash_map<char*,int*> tab; tab.insert(std::make_pair(&a,&i));

@Goten

J'ai pas compris ta question!! :oops: Je ne suis que stagiaire, j'ai encore beaucoup de choses à apprendre...

@Screetch

C'est vrai, j'avais pas vu. j'ai essayé ceci et ça marche:

Code:

1
2
3
4
5
 
char a = 0x41;
int i =  1;
__gnu_cxx::hash_map<char*,int*> tab;
tab[&a];

mais j'ai essayé cela et ça ne marche pas:

Code:

1
2
3
4
5
6
7
8
9
 
template <typename K, typename T>
class hash : __gnu_cxx::hash_map<K,T>
{
};
 
// dans le main
hash<char*,int*> tab;
tab[&a];

message d'erreur:

Code:

1
2
3
 
`_Tp& __gnu_cxx::hash_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc>::operator[](const typename __gnu_cxx::hashtable<std::pair<const _Key, _Tp>, _Key, _HashFcn, std::_Select1st<std::pair<const _Key, _Tp> >, _EqualKey, _Alloc>::key_type&) [with _Key = char*, _Tp = int*, _HashFcn = __gnu_cxx::hash<char*>, _EqualKey = std::equal_to<char*>, _Alloc = std::allocator<int*>]' is inaccessible within this context 
`__gnu_cxx::hash_map<char*, int*, __gnu_cxx::hash<char*>, std::equal_to<char*>, std::allocator<int*> >' is not an accessible base of `hash<char*, int*>'

J'ai aussi essayé cela:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
template <typename K, typename T>
class hash : __gnu_cxx::hash_map<K,T>
{   
};
 
template <typename K, typename T>
class iter : __gnu_cxx::hash_map<K,T>::iterator
{   
};
 
// dans le main:
hash<char*,int*> tab;
iter<char*,int*> it;
it = tab.begin();

Message d'erreur:

Code:

1
2
3
 
no match for 'operator=' in 'it = ((__gnu_cxx::hash_map<char*, int*, __gnu_cxx::hash<char*>, std::equal_to<char*>, std::allocator<int*> >*)(&tab))->__gnu_cxx::hash_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc>::begin [with _Key = char*, _Tp = int*, _HashFcn = __gnu_cxx::hash<char*>, _EqualKey = std::equal_to<char*>, _Alloc = std::allocator<int*>]()'
candidates are: iter<char*, int*>& iter<char*, int*>::operator=(const iter<char*, int*>&)

Je comprends pas!

Vous allez me dire, quel est l'intérêt d'hériter ainsi ; c'est parce que je dois garder les noms des anciennes méthodes de Roguewave donc les coder dans ma classe juste pour créer une interface.

Désolé de vous embêter avec mon problème tordu...