Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » map iterator derefenzierbar machen

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
09.09.2010, 14:30 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


Hallo Ihr,

aus Kompatibilitätsgründen zu einer alten Library, bräuchte ich folgende Konstruktion:

im prinzip bildet die alte library eine xml ab, hat also entry und entity typen.

nun hat jeder entity 2 iteratoren: entity_iterator und entry_iterator.

Diese konnten mit "*eiterator" auf die Daten zugreifen

In meiner "neuen" Library, welche als Kompatilibätswrapper für eine ganz neue Library ist, ist das ganze jedoch als "std::map" implementiert, d.h "*eiterator" funktioniert nicht mehr, sondern man müsste überall "eiterator->second" schreiben.

gibts ne einfache möglichkeit, diese iteratordereferenzierbarkeitsfunktionalität (was für ein wort...) auf die std::map<T>::iterator'en abzubilden?

achso, diskutiert nicht bzgl sinn der ganzen sache ... das ist einfach so hinzunehmen, da viel zu viel code auf diese alte bibliothek aufbaut

danke schonmal
--
class God : public ChuckNorris { };

Dieser Post wurde am 09.09.2010 um 14:40 Uhr von FloSoft editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
09.09.2010, 17:17 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


hmm habs glaub hingekriegt:


C++:
    class CfgCompatEntityIterator
    {
    public:
        typedef std::map<std::string, const CfgCompatEntity*> map_t;

        CfgCompatEntityIterator(map_t::const_iterator iter) : iter_(iter) {}

        bool operator== (const CfgCompatEntityIterator& iter) const    {    return iter_ == iter.iter_;    }
        bool operator!= (const CfgCompatEntityIterator& iter) const    {    return iter_ != iter.iter_;    }
        
        CfgCompatEntityIterator operator=(map_t::iterator iter)    {    iter_ = iter;    return *this;    }

        bool operator== (const map_t::iterator& iter)    { return iter_ == iter;    }
        bool operator!= (const map_t::iterator& iter)    { return iter_ != iter;    }

        const CfgCompatEntity* operator*()    {    return iter_->second;    }

        map_t::const_iterator operator++()    {    return ++iter_;    }
        map_t::const_iterator operator--()    {    return --iter_;    }

    private:
        map_t::const_iterator iter_;
    };



jetzt hätt ich nur eigentlich gern nen template draus gemacht, nur


C++:
    template<typename T>
    class CfgCompatEntityIterator
    {
    public:
        typedef std::map<std::string, const T*> map_t;

        CfgCompatEntityIterator(map_t::const_iterator iter) : iter_(iter) {}


frisst er nicht ( er meckert dann const_iterator ist nicht definiert und so geschichten)

was mach ich da falsch?
--
class God : public ChuckNorris { };

Dieser Post wurde am 09.09.2010 um 17:21 Uhr von FloSoft editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
09.09.2010, 17:24 Uhr
0xdeadbeef
Gott
(Operator)


Boost to the rescue!

C++:
#include <boost/iterator/transform_iterator.hpp>

#include <tr1/functional>
#include <iostream>
#include <map>

typedef std::map<int, int> map_t;
typedef boost::transform_iterator<std::tr1::function<int (map_t::const_reference)>,
                                  map_t::const_iterator> map_value_iterator;

int get_pair_second(map_t::const_reference p) {
  return p.second;
}

int main() {
  map_t m;

  m[1] = 3;
  m[2] = 1;
  m[3] = 4;
  m[4] = 1;

  for(map_value_iterator i(m.begin(), get_pair_second);
      i != map_value_iterator(m.end(), get_pair_second);
      ++i) {
    std::cout << *i << std::endl;
  }
}


--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
09.09.2010, 17:24 Uhr
0xdeadbeef
Gott
(Operator)


Zum zweiten:

C++:
CfgCompatEntityIterator(typename map_t::const_iterator iter) : iter_(iter) {}


--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
09.09.2010, 19:30 Uhr
FloSoft
Medialer Over-Flow
(Administrator)



C++:
for(map_value_iterator i(m.begin(), get_pair_second);
      i != map_value_iterator(m.end(), get_pair_second);
      ++i) {
    std::cout << *i << std::endl;
  }



das kann ich halt auch net verwenden, da die iteratoren ja eben in den anwendungen verstreut verwendet werden.
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
09.09.2010, 19:30 Uhr
FloSoft
Medialer Over-Flow
(Administrator)



Zitat von 0xdeadbeef:
Zum zweiten:

C++:
CfgCompatEntityIterator(typename map_t::const_iterator iter) : iter_(iter) {}



*klatsch-an-stirn* ... danke
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
09.09.2010, 21:15 Uhr
0xdeadbeef
Gott
(Operator)


Etwas in der Art vielleicht?

C++:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <boost/iterator/transform_iterator.hpp>

#include <tr1/functional>

#include <algorithm>
#include <iostream>
#include <iterator>
#include <map>

template<typename pair_t>
struct pair_second_getter {
  typedef typename pair_t::second_type result_type;

  typename pair_t::second_type operator()(pair_t const &p) const {
    return p.second;
  }
};

template<typename iterator_t>
struct map_value_iterator
  : boost::transform_iterator<pair_second_getter<typename std::iterator_traits<iterator_t>::value_type>,
                              iterator_t> {
  map_value_iterator(iterator_t iter)
    : boost::transform_iterator<pair_second_getter<typename std::iterator_traits<iterator_t>::value_type>,
                                iterator_t>(iter, pair_second_getter<typename std::iterator_traits<iterator_t>::value_type>()) { }
};

template<typename T1, typename T2>
struct map_value_iterators {
  typedef map_value_iterator<typename std::map<T1, T2>::              iterator>               iterator;
  typedef map_value_iterator<typename std::map<T1, T2>::        const_iterator>         const_iterator;
  typedef map_value_iterator<typename std::map<T1, T2>::      reverse_iterator>       reverse_iterator;
  typedef map_value_iterator<typename std::map<T1, T2>::const_reverse_iterator> const_reverse_iterator;
};

int main() {
  std::map<int, int> m;

  m[1] = 3;
  m[2] = 1;
  m[3] = 4;
  m[4] = 1;

  std::copy(map_value_iterators<int, int>::const_iterator(m.begin()),
            map_value_iterators<int, int>::const_iterator(m.end()),
            std::ostream_iterator<int>(std::cout, "\n"));

  std::copy(map_value_iterators<int, int>::const_reverse_iterator(m.rbegin()),
            map_value_iterators<int, int>::const_reverse_iterator(m.rend()),
            std::ostream_iterator<int>(std::cout, "\n"));
}


--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
10.09.2010, 12:30 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


habs nun mit dem von dir korrigierten template probiert, das klappt wunderbar.

alles andere würde codeänderungen in den anwendungsprogrammen nach sich ziehen, und das ist nicht gewünscht.
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
10.09.2010, 15:59 Uhr
0xdeadbeef
Gott
(Operator)


Du darfst natürlich nur nicht auf die Idee kommen, diese Iteratoren polymorphisch einzusetzen (kein virtueller Destruktor). Das ist aber bei Iteratoren eh eher ungewöhnlich.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
11.09.2010, 17:32 Uhr
FloSoft
Medialer Over-Flow
(Administrator)



Zitat von 0xdeadbeef:
Du darfst natürlich nur nicht auf die Idee kommen, diese Iteratoren polymorphisch einzusetzen (kein virtueller Destruktor). Das ist aber bei Iteratoren eh eher ungewöhnlich.

jo das wird nicht gemacht (zum glück ...)
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: