Iterator-Adapter nur die Werte in einer Karte iterieren?

Question

Ich bin gerade zurück in C ++ immer nach ein paar Jahren eine Menge von C # zu tun, und vor kurzem Objective C.

Eine Sache, die ich vorher gemacht habe, ist meinen eigenen Iterator-Adapter für std :: map zu rollen, die nur den Wert Teil deref wird, anstatt das Schlüssel-Wert-Paar. Dies ist eine durchaus gängig und natürliche Sache zu tun. C # bietet diese Möglichkeit mit seinen Schlüsseln und Werten Eigenschaften seiner Klasse Dictionary. Objective-C NSDictionary, ähnlich, hat AllKeys und allValues.

Da ich waren „weg“, hat Erhöhung der Reichweite und ForEach Bibliotheken erworben, die ich nun ausgiebig mit bin. Ich fragte mich, ob zwischen den beiden dort einige Anlage war das gleiche zu tun, aber ich habe nicht in der Lage, etwas zu finden.

Ich denke an-Boost des Iterators Adapter etwas auf Klopfen verwenden, aber bevor ich hinunter diesen Weg zu gehen dachte ich, ich würde hier fragen, ob jemand einer solchen Anlage in Boost-weiß oder woanders fertig gemacht?

Answer 1

Ich glaube nicht, dass es etwas gibt, aus dem Kasten heraus. Sie können mit boost :: make_transform.

template<typename T1, typename T2> T2& take_second(const std::pair<T1, T2> &a_pair) 
{
  return a_pair.second;
}

void run_map_value()
{
  map<int,string> a_map;
  a_map[0] = "zero";
  a_map[1] = "one";
  a_map[2] = "two";
  copy( boost::make_transform_iterator(a_map.begin(), take_second<int, string>),
    boost::make_transform_iterator(a_map.end(), take_second<int, string>),
    ostream_iterator<string>(cout, "\n")
    );
}

Answer 2

die vorherige Antwort Austausch findet bei sonst jemand dies wie ich es tat. Wie Boost 1.43, gibt es einige häufig verwendete Bereich mitgelieferten Adapter. In diesem Fall möchten Sie boost :: Adapter :: map_values. Das entsprechende Beispiel: http://www.boost.org/doc/libs/1_46_0/libs/range/doc/html/range/reference/adaptors/reference/map_values.html#range.reference.adaptors .reference.map_values.map_values_example

Answer 3

Es gibt einen Ladebereich Adapter für genau diesen Zweck. Siehe http: //www.boost .org / doc / libs / 1_53_0 / libs / Bereich / doc / html / Bereichs- / reference / Adapter / reference / map_values.html

(Dieses Beispiel von dort abgeschaut)

int main(int argc, const char* argv[])
{
    using namespace boost::assign;
    using namespace boost::adaptors;

    std::map<int,int> input;
    for (int i = 0; i < 10; ++i)
    input.insert(std::make_pair(i, i * 10));

    boost::copy(
        input | map_values,
        std::ostream_iterator<int>(std::cout, ","));

    return 0;
}

Answer 4

David Antwort Fortsetzung, gibt es eine andere Möglichkeit, die die Wasse zu setzen, indem eine abgeleitete Klasse von boost :: transform_iterator zu schaffen. Ich bin mit dieser Lösung in meinen Projekten:

namespace detail
{

template<bool IsConst, bool IsVolatile, typename T>
struct add_cv_if_c
{
    typedef T type;
};
template<typename T>
struct add_cv_if_c<true, false, T>
{
    typedef const T type;
};
template<typename T>
struct add_cv_if_c<false, true, T>
{
    typedef volatile T type;
};
template<typename T>
struct add_cv_if_c<true, true, T>
{
    typedef const volatile T type;
};

template<typename TestConst, typename TestVolatile, typename T>
struct add_cv_if: public add_cv_if_c<TestConst::value, TestVolatile::value, T>
{};

}   // namespace detail


/** An unary function that accesses the member of class T specified in the MemberPtr template parameter.

    The cv-qualification of T is preserved for MemberType
 */
template<typename T, typename MemberType, MemberType T::*MemberPtr>
struct access_member_f
{
    // preserve cv-qualification of T for T::second_type
    typedef typename detail::add_cv_if<
        std::tr1::is_const<T>, 
        std::tr1::is_volatile<T>, 
        MemberType
    >::type& result_type;

    result_type operator ()(T& t) const
    {
        return t.*MemberPtr;
    }
};

/** @short  An iterator adaptor accessing the member called 'second' of the class the 
    iterator is pointing to.
 */
template<typename Iterator>
class accessing_second_iterator: public 
    boost::transform_iterator<
        access_member_f<
            // note: we use the Iterator's reference because this type 
            // is the cv-qualified iterated type (as opposed to value_type).
            // We want to preserve the cv-qualification because the iterator 
            // might be a const_iterator e.g. iterating a const 
            // std::pair<> but std::pair<>::second_type isn't automatically 
            // const just because the pair is const - access_member_f is 
            // preserving the cv-qualification, otherwise compiler errors will 
            // be the result
            typename std::tr1::remove_reference<
                typename std::iterator_traits<Iterator>::reference
            >::type, 
            typename std::iterator_traits<Iterator>::value_type::second_type, 
            &std::iterator_traits<Iterator>::value_type::second
        >, 
        Iterator
    >
{
    typedef boost::transform_iterator<
        access_member_f<
            typename std::tr1::remove_reference<
                typename std::iterator_traits<Iterator>::reference
            >::type, 
            typename std::iterator_traits<Iterator>::value_type::second_type, 
            &std::iterator_traits<Iterator>::value_type::second
        >, 
        Iterator
    > baseclass;

public:
    accessing_second_iterator(): 
        baseclass()
    {}

    // note: allow implicit conversion from Iterator
    accessing_second_iterator(Iterator it): 
        baseclass(it)
    {}
};

Dies führt zu noch saubereren Code:

void run_map_value()
{
  typedef map<int, string> a_map_t;
  a_map_t a_map;
  a_map[0] = "zero";
  a_map[1] = "one";
  a_map[2] = "two";

  typedef accessing_second_iterator<a_map_t::const_iterator> ia_t;
  // note: specify the iterator adaptor type explicitly as template type, enabling 
  // implicit conversion from begin()/end()
  copy<ia_t>(a_map.begin(), a_map.end(),
    ostream_iterator<string>(cout, "\n")
  );
}