std::copy to std:: cout for std:: pair

Nie ma standardowego sposobu na wydrukowanie std::pair ponieważ, cóż, sposób, w jaki chcesz to wydrukować, prawdopodobnie różni się od sposobu, w jaki następny facet chce to zrobić. Jest to dobry przypadek użycia dla niestandardowego functora lub funkcji lambda. Następnie możesz przekazać to jako argument std::for_each, aby wykonać pracę.

typedef std::map<size_t, size_t> MyMap;

template <class T>
struct PrintMyMap : public std::unary_function<T, void>
{
    std::ostream& os;
    PrintMyMap(std::ostream& strm) : os(strm) {}

    void operator()(const T& elem) const
    {
        os << elem.first << ", " << elem.second << "\n";
    }
}

Aby wywołać ten funktor z twojego kodu:

std::for_each(some_map.begin(),
              some_map.end(),
              PrintMyMap<MyMap::value_type>(std::cout));

Chciałbym tylko zaznaczyć, że dodawanie rzeczy do przestrzeni nazw std:: jest nielegalne zgodnie ze standardem C++ (patrz sekcja 17.4.3.1).

Chcesz transformującego iteratora. Ten rodzaj iteratora otacza inny iterator, przekazując wszystkie metody pozycjonowania, takie jak operator++ i operator==, ale redefiniuje operator* i operator ->.

Szybki szkic:

template <typename ITER> 
struct transformingIterator : private ITER {
    transformingIterator(ITER const& base) : ITER(base) {}
    transformingIterator& operator++() { ITER::operator++(); return *this; }
    std::string operator*() const
    {
        ITER::value_type const& v = ITER::operator*();
        return "[" + v->first +", " + v->second + "]";
    }
...

Tylko przechodziłem, ale to mi się udało, więc może komuś innemu (wersja wycięta):

template<typename First, typename Second>
struct first_of {
    First& operator()(std::pair<First, Second>& v) const {
        return v.first;
    }
};

Podany przypadek użycia:

transform (v.begin (), v.end (), 
           ostream_iterator<int>(cout, "\n"), first_of<int, string> ());

Używając Boost Lambda, możesz spróbować czegoś takiego. Wersja mam Boost Lambda, to faktycznie nie działa, będę testować i naprawić później.

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

using namespace boost::lambda;

std::for_each( some_map.begin(), some_map.end(), 
               std::cout << bind( &std::map<size_t,size_t>::value_type::first, _1 )
                         << ","
                         << bind( &std::map<size_t,size_t>::value_type::second, _1 ) );

[wolałbym usunąć tę odpowiedź, ale na razie ją zostawię, na wypadek gdyby ktoś uznał dyskusję za interesującą.]

ponieważ jest to rozsądne rozszerzenie biblioteki std, po prostu umieściłbym je w przestrzeni nazw std, zwłaszcza jeśli jest to jednorazowa rzecz. Możesz po prostu zadeklarować, że jest statyczny, aby zapobiec powodowaniu błędów linkera, jeśli ktoś inny zrobi to samo gdzieś indziej.

Innym rozwiązaniem, które przychodzi na myśl, jest stworzenie wrappera dla std:: pair:

template<class A, class B>
struct pairWrapper {
  const std::pair<A,B> & x;
  pairWrapper(const std::pair<A,B> & x) : x(x) {}
}

template<class A,class B>
std::ostream & operator<<(std::ostream & stream, const pairWrapper<A,B> & pw) { ... }

    for (const auto& your_pair : your_container)
        your_stream << "[" << your_pair.first << "," << your_pair.second << "]" << endl;

 for_each(some_map.begin(), some_map.end(), [](const std::map < size_t, size_t >::value_type &ite){
             cout<<ite.first<<" "<<ite.second<<endl;

}); 

- - - jest dobrze z C++11

Oto adapter do użycia z std::copy i std::ostream_iterator dla typu std::pair. Kończy się to trzymaniem jednego dodatkowego odniesienia, ale optymalizacja kompilatora może się tym zająć. BTW, pierwszy typ w std::pair z std::map::value_type będzie const.

template <typename pair_type>
class pair_adaptor
{
public:
    const pair_type &m;
    pair_adaptor(const pair_type &a) : m(a) {}

    friend std::ostream &operator << (std::ostream &out, 
        const pair_adaptor <pair_type> &d)
    {
        const pair_type &m = d.m;
        return out << m.first << " => " << m.second;
    }
};

typedef std::map<size_t, size_t>::value_type value_type;

std::copy (mymap.begin(), mymap.end(),
    std::ostream_iterator < 
        pair_adaptor <value_type> > (std::cout, "\n"));

std::copy (mymap.begin(), mymap.end(),
    std::ostream_iterator < 
        pair_adaptor <
            std::pair<const size_t, size_t>>> (std::cout, "\n"));