How can I make std::make_pair usable with std::bind*? - c++

Question

I'd like to use std::make_pair usable with e.g. std::bind2nd so that I get an unary function object which I could use with e.g. std::transform.
Right now I'm using
template <typename T, typename U>
struct pair_creator : std::binary_function<T, U, std::pair<T, U> >
{
std::pair<T, U> operator()( T arg1, U arg2 ) const {
return std::make_pair( arg1, arg2 );
}
};
// ...
std::transform( start1, end2, start2, std::bind2nd( pair_creator<int, bool>(), true ) );
but I wonder - is there an easier way to make std::make_pair (or potentially any other binary function) usable with the binders except by writing little wrapper classes like pair_creator by hand?
I'd need a C++03 solution (for some obscure reason, stackoverflow always rewrites my c++0x tag to c++11 when saving the post...).

Answer 1

You need std::ptr_fun, which turns a plain function pointer into an adaptable binary function object (or a unary function object, if you pass it a one-arg function):
#include <functional>
#include <utility>
#include <vector>
#include <algorithm>
#include <iostream>
int main() {
std::vector<int> intvec;
intvec.push_back(0);
intvec.push_back(1);
std::vector<std::pair<int,bool> > pairvec(intvec.size());
std::transform(
intvec.begin(),
intvec.end(),
pairvec.begin(),
// this is the significant line
std::bind2nd(std::ptr_fun(std::make_pair<int, bool>), true)
);
std::cout << pairvec[1].first << " " << pairvec[1].second << "\n";
}
ptr_fun is declared:
template <class Arg1, class Arg2, class Result>
pointer_to_binary_function<Arg1,Arg2,Result>
ptr_fun(Result (*)(Arg1,Arg2));
And for the unary version:
template <class Arg, class Result>
pointer_to_unary_function<Arg,Result>
ptr_fun(Result (*)(Arg));

Answer 2

Use lambda don't need to use bind adaptor.
std::vector<int> start1 = list_of(1)(2)(3)(4)(5);
std::vector<int> start2 = list_of(10)(20)(30)(40)(50);
std::vector<Pair> w_vecofpair; // vector of pair
w_vofpair.reserve(start1.size());
// create pair using lambda
std::transform( std::begin(start1), std::end(start1), std::begin(start2), // ranges
std::back_inserter(w_vecofpair), // result
[](int a,int b) { return std::make_pair(a,b);}); // pair creator
for (auto& pairInt : w_vecofpair)
{
std::cout << pairInt << "\n";
}
// bind 2nd arg to some value, say 2
std::transform( std::begin(start1), std::end(start1), std::begin(start2),
std::back_inserter(w_vecofpair), [](int a, int b) { return std::make_pair(a,2);});
for (auto& second : w_vecofpair | map_values)
{
std::cout << "The second value of our bind 2nd is: " << second << "\n";
assert(second==2);
}