Les pointeurs comme clés dans la carte C++ STL

J'ai une question sur comment pointeurs pour un objet personnalisé sont traités lorsqu'ils sont utilisés comme Clés dans une carte. Plus précisément, si je définir 

std::map< CustomClass*, int > foo;

Serait la valeur par défaut C++ mise en œuvre pour gérer ces pointeurs? Ou ai-je besoin de définir une coutume comparateur de fonction pour gérer cela? En général, il est de bonne pratique d'utiliser des pointeurs vers des objets comme des clés?

  • Tout ce qui soutient less<T> peut être utilisé dans une carte. Voir stackoverflow.com/questions/1098966/...
  • Un inconvénient possible en utilisant des indicateurs clés dans les cartes, c'est que l'ordre des éléments est non-déterministe (dépend de leur adresse de mémoire). Si vous avez besoin d'itérer sur les éléments d'un déterministe de l'ordre, vous ne pouvez pas utiliser les pointeurs comme des clés. Cela peut être important dans les jeux multijoueurs.
InformationsquelleAutor Ammar Husain | 2014-08-04
  1. 49

    Le défaut de mise en œuvre permettra de comparer les adresses enregistrées par les pointeurs, objets seront considérés comme des clés différentes. Cependant, la logique de l'état de l'objet ne seront pas considérées. Par exemple, si vous utilisez std::string * comme la clé, deux std::string objets avec le même texte de "Hello" serait considérée comme une clé différente! (Lorsqu'ils sont stockés dans la carte par leurs adresses)

    C'est ok d'utiliser des pointeurs comme des clés, aussi longtemps que vous comprenez la différence importante ci-dessus.

    • Oui c'est un excellent point! L'hypothèse est mon cas, bien que les sont des pointeurs vers des objets uniques.
    InformationsquelleAutor Neil Kirk
  2. 21

    Pointeurs seront traitées, mais en comparaison de pointeurs (mémoire de l'ordre). Vous devez passer personnalisé less foncteur si vous souhaitez comparer les objets:

    template<class T> struct ptr_less {
    bool operator()(T* lhs, T* rhs) {
        return *lhs < *rhs; }};
map<Object*,int,ptr_less<Object>> mymap;
    • Cela devrait être choisi comme la réponse correcte. La comparaison de pointeurs est (presque toujours sûrement) pas de sens et va certainement conduire à des bugs qui sont extrêmement difficiles à détecter.
    • C'est bien si vous voulez juste utiliser le pointeur comme une clé pour une recherche rapide dans un plan. Souvent, les cartes sont juste utilisés comme tables de consultation et la commande n'est pas très pertinent.
    • Je n'ai jamais dit qu'il ne l'est pas, si vous savez ce que vous faites (j'ai bien dit: les Pointeurs seront traitées, mais en comparaison de pointeurs = mémoire de l'ordre). J'ai seulement ajouté solution possible si vous vous attendiez à comparer les objets, rien de plus, rien de moins.
    • N'en déplaise @firda - commentaire était destiné commentaire ci-dessus de la mine.
    InformationsquelleAutor firda
  3. 7

    C++ standard fourni par la spécialisation des std::less pour les pointeurs, donc oui, vous pouvez les utiliser comme carte de touches, etc.

    InformationsquelleAutor Wojtek Surowka
  4. 3

    En laissant de côté de la légalité de cette et d'éventuels malentendus sémantiques, abordée déjà, je ne vois pas de raison d'utiliser std::map ici plutôt que de std::unordered_map. Il y a déjà des interceptions de ce en Boost et Visual C++ si vous êtes sur un pré-compilateur C++11.

    Puisque vous semblez être l'aide d'un pointeur pour représenter un objet unique, quelque chose comme boost::mouche pourraient être applicables.

    • Malheureusement, je n'ai pas saisi le C++11 domaine pourtant!
    InformationsquelleAutor Steve Townsend
  5. 3

    Pointeurs peuvent être utilisés comme clés, mais surtout avec une std::map (ou std::set), je vous le déconseille. Le comportement du programme n'est pas déterministe, c'est à dire lorsque l'on parcourt la carte de l'ordre dans lequel les éléments de la carte sont itérées n'est pas garanti d'être le même. Cela dépend vraiment de l'adresse mémoire de l'objet (clé). Jetez un oeil à cet exemple, comme vous pouvez le voir, indépendamment de l'ordre d'insertion dans la carte les éléments sont répétées de façon déterministe, lorsque la clé est une chaîne plutôt qu'un pointeur.

    http://ideone.com/VKirct

    #include <iostream>
#include <map>
using namespace std;
class SomeClass {
public:
SomeClass(const std::string& name): m_name(name) {}
std::string GetName()const {return m_name; }
bool operator <(const SomeClass& rhs) const { return m_name < rhs.m_name; }
private:
std::string m_name;
};
auto print_seq  = [](const auto& seq) { for (const auto& itr: seq) {std::cout << itr.second << " , ";} std::cout << std::endl;};
int main() {
//your code goes here
std::map<SomeClass*, std::string> pointer_keyed_map;
SomeClass s3("object3");
SomeClass s1("object1");
SomeClass s2("object2");
pointer_keyed_map.insert(std::make_pair(&s1, s1.GetName()));
pointer_keyed_map.insert(std::make_pair(&s2, s2.GetName()));
pointer_keyed_map.insert(std::make_pair(&s3, s3.GetName()));
std::cout << "Pointer based keys: object order" << std::endl;
print_seq(pointer_keyed_map);
std::map<SomeClass, std::string> int_keyed_map;
int_keyed_map.insert(std::make_pair(s3, s3.GetName()));
int_keyed_map.insert(std::make_pair(s1, s1.GetName()));
int_keyed_map.insert(std::make_pair(s2, s2.GetName()));
std::cout << "String based keys: object order" << std::endl;
print_seq(int_keyed_map);
return 0;
}
    InformationsquelleAutor blueskin