Surcharge des opérateurs pour les cartes C ++

Question

J'ai besoin d'aide pour comprendre certaines instructions de surcharge d'opérateur C ++. La classe est déclarée comme ceci:

template <class key_t, class ipdc_t>
class ipdc_map_template_t : public ipdc_lockable_t
{
    ...
    typedef map<key_t,
            ipdc_t*,
            less<key_t>> map_t;
    ...

Le créateur de la classe a créé un itérateur pour la structure de carte interne:

struct iterator : public map_t::iterator
{
    iterator() {}
    iterator(const map_t::iterator & it)
        : map_t::iterator(it) {}
    iterator(const iterator & it)
        : map_t::iterator(
            *static_cast<const map_t::iterator *>(&it)) {}
    operator key_t() {return ((this->operator*()).first);}           // I don't understand this.
    operator ipdc_t*() const {return ((this->operator*()).second);}  // or this.

};

Et begin () et end () retournent les begin () et end () de la carte:

iterator begin() {IT_ASSERT(is_owner()); return map.begin();}
iterator end() {return map.end();}

Ma question est la suivante: si j’ai un itérateur, comment puis-je utiliser ces surcharges pour obtenir la clé et la valeur?

ipdc_map_template_t::iterator iter;
    for( iter = my_instance.begin();
             iter != my_instance.end();
         ++iter )
    {
        key_t my_key = ??????;
        ipdc_t *my_value = ??????;

    }

Answer 1

Ce sont des opérateurs de transtypage, vous pouvez donc faire ceci:

{
    key_t   key = iter;
    ipdc_t *val = iter;
}

Ou, puisque ipdc_map_template :: iterator est une sous-classe de std :: map :: iterator , vous pouvez toujours utiliser les accesseurs d'origine (que je trouve plus lisibles). :

{
    key_t   key = (*iter).first;
    ipdc_t *val = (*iter).second;

    // or, equivalently
    key_t   key = iter->first;
    ipdc_t *val = iter->second;

}

Answer 2

opérateur key_t () et opérateur ipdc_t * () sont tous deux des définitions castées. Donc, étant donné un itérateur tel que défini dans la classe, vous devriez pouvoir simplement assigner vos variables:

ipdc_map_template_t::iterator iter;
    for( iter = my_instance.begin();
         iter != my_instance.end();
         ++iter )
    {
            key_t my_key = iter;
            ipdc_t my_value = iter;
    }

Answer 3

Le créateur de la classe a remplacé les opérateurs de distribution. Donc, en assignant simplement l’itérateur à un objet du type correct, il devrait se convertir automatiquement via les méthodes aux valeurs correctes.

N.B. : le type de valeur est stocké sous forme de pointeur. Ainsi, lorsque vous extrayez la valeur, vous devez spécifier le pointeur sur le type de valeur que vous avez spécifié dans l'interface de la carte.

 typedef ipdc_map_template_t<int,std::string>   MyMap;
 MyMap    mymap;

 for(MyMap::iterator iter = mymap.begin();
                     iter != mymap.end();
                     ++iter )
    {
            int          my_key   = iter;
            std::string* my_value = iter;

    }

Je ne suis pas sûr d’être d’accord avec la direction prise ici. Cela rend-il le code plus lisible? Je me contenterais de l’itérateur de carte à l’ancienne semble plus utilisable. Ce conteneur est-il défini dans une bibliothèque spécialisée dont vous avez besoin ou serait-il utile de consulter les conteneurs du pointeur de suralimentation?