adaptateur itérateur pour parcourir uniquement les valeurs d'une carte ?

Question

Je me remets tout juste au C++ après avoir passé quelques années à faire beaucoup de C#, et récemment de l'Objective C.

Une chose que j'ai déjà faite est de créer mon propre adaptateur d'itérateur pour std::map qui déréférencera uniquement la partie valeur, plutôt que la paire clé-valeur. C'est une chose assez courante et naturelle à faire. C# offre cette possibilité avec les propriétés Keys et Values de sa classe Dictionary. Le NSDictionary d'Objective-C, de la même manière, possède les propriétés allKeys et allValues.

Depuis mon absence, Boost a acquis les bibliothèques Range et ForEach, que j'utilise maintenant de manière intensive. Je me demandais s'il existait un moyen de faire la même chose entre les deux, mais je n'ai rien trouvé.

Je pense faire quelque chose en utilisant les adaptateurs d'itérateurs de Boost, mais avant de m'engager dans cette voie, j'ai pensé demander ici si quelqu'un connaissait un tel dispositif dans Boost, ou quelque part d'autre prêt à l'emploi ?

Answer 1

Je remplace la réponse précédente, au cas où quelqu'un d'autre trouverait la même chose que moi. Depuis la version 1.43 de boost, certains adaptateurs de gamme couramment utilisés sont fournis. Dans ce cas, vous devez utiliser boost::adaptors::map_values. L'exemple pertinent : 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 2

Je ne pense pas qu'il y ait quoi que ce soit qui sorte de la boîte. Vous pouvez utiliser 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 3

Il existe un adaptateur de plage de suralimentation qui sert précisément à cette fin. Voir aussi http://www.boost.org/doc/libs/1_53_0/libs/range/doc/html/range/reference/adaptors/reference/map_values.html

(Cet exemple est tiré de ce site)

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

Dans la continuité de la réponse de David, il y a une autre possibilité de mettre la bile en créant une classe dérivée de boost::transform_iterator. J'utilise cette solution dans mes projets :

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)
    {}
};

Cela permet d'obtenir un code encore plus propre :

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")
  );
}