boost库bind的一些用法

std::for_each(vect.begin(), vect.end(), std::mem_fun_ref(&class::fun));

std::for_each(vect.begin(), vect.end(), boost::bind(&class::fun, _1));

ptr

std::for_each(vect.begin(), vect.end(), std::mem_fun(&class::fun))

std::for_each(vect.begin(), vect.end(), boost::bind(&class::fun, _1));

std::string surname() const {

 return name_;

}

#include <iostream>

#include <boost/function.hpp>

bool some_func(int i, double d)

{

 return i > d;

}

int main()

{

 boost::function<bool (int, double)> f;

 f = &some_func;

 f(10, 1.1);

}

#include <iostream>
#include <vector>
#include <algorithm>
#include <boost/function.hpp>
void print_new_value(int i)
{
 std::cout << "The value has been updated and is now" << i << std::endl;
}
void interested_in_the_change(int i)
{
 std::cout << "Ah, the value has changed." << std::endl;
}
class notifier
{
 typedef void (*function_type)(int);
 std::vector<function_type> vec_;
 int value_;
public:
 void add_observer(function_type t)
 {
  vec_.push_back(t);
 }
 void change_value(int i)
 {
  value_ = i;
  for (std::size_t i=0; i<vec_.size(); ++i)
  {
   (*vec_[i]) (value_);
  }
 }
};
int main()
{
 notifier n;
 n.add_observer(&print_new_value);
 n.add_observer(&interested_in_the_change);
 n.change_value(42);
}

--------------------------------------------

#include <iostream>

#include <vector>

#include <algorithm>

#include <boost/function.hpp>

class some_class

{

public:

 void do_stuff(int i) const

 {

  std::cout << "OK, Stuff is done. " << i << std::endl;

 }

};

int main()

{

 //boost::function<void(some_class, int)> f;

 //f=&some_class::do_stuff;

 //f(some_class(), 2);

 //boost::function<void(some_class&, int)> f;

 //f=&some_class::do_stuff;

 //some_class s;

 //f(s, 2);

 boost::function<void(some_class*, int)> f;

 f = &some_class::do_stuff;

 some_class s;

 f(&s, 3);

}

------------------------------------------------------------------

#include <iostream>

#include <vector>

#include <algorithm>

#include <boost/function.hpp>

class keepint_state

{

 int total_;

public:

 keepint_state():total_(0) {}

 int operator()(int i)

 {

  total_ += i;

  return total_;

 }

 int total() const

 {

  return total_;

 }

};

int main()

{

 keepint_state ks;

 boost::function<int(int)> f1;

 //f1 = ks;

 f1 = boost::ref(ks);

 boost::function<int(int)> f2;

 //f2 = ks;

 f2 = boost::ref(ks);

 std::cout << "The current total is " << f1(10) << std::endl;

 std::cout << "The current total is " << f2(10) << std::endl;

 std::cout << "After adding 10 two times, the total is " << ks.total() << std::endl;

}

 data my(1, 11);

 if(std::binary_search(vec.begin(), vec.end(), my,

  boost::bind<bool>(

  std::less<unsigned int>(),

  boost::bind(&data::a_,_1),

  boost::bind(&data::a_,_2)

  )))

 {

 int a =0;

 }

 iter = std::lower_bound(vec.begin(), vec.end(), my,

  boost::bind<bool>(

  std::less<unsigned int>(),

  boost::bind(&data::a_,_1),

  boost::bind(&data::a_,_2)

  ));

 if(iter!=vec.end())

 {

  std::cout << "========" << std::endl;

  std::cout << (*iter).a_ << " " << (*iter).b_ << std::endl;

 }

 iter = std::upper_bound(vec.begin(), vec.end(), my,

  boost::bind<bool>(

  std::less<unsigned int>(),

  boost::bind(&data::a_,_1),

  boost::bind(&data::a_,_2)

  ));

 if(iter!=vec.end())

 {

  std::cout << "========" << std::endl;

  std::cout << (*iter).a_ << " " << (*iter).b_ << std::endl;

 }

  std::sort(

   vect_enter_copy_.begin(),

   vect_enter_copy_.end(),

   boost::bind<bool>(

   std::less<int>(),

   boost::bind(&enter_copy_data::id_, _1),

   boost::bind(&enter_copy_data::id_, _2)));

  //method 1

  //ptr_vect_type::iterator iter = std::find_if(

  // vect_enter_copy_.begin(),

  // vect_enter_copy_.end(),

  // boost::bind<bool>(

  // std::equal_to<int>(),

  // copy_id,

  // boost::bind(&enter_copy_data::get_id, _1)));

  //if(iter != vect_enter_copy_.end())

  // ret = (*iter).live_time_;

  //enter_copy_data data(copy_id);

  //method 2

  //ptr_vect_type::iterator iter = std::lower_bound(vect_enter_copy_.begin(), vect_enter_copy_.end(), data,

  // boost::bind<bool>(

  // std::less<unsigned int>(),

  // boost::bind(&enter_copy_data::id_, _1),

  // boost::bind(&enter_copy_data::id_, _2)

  // ));

  //if(iter!=vect_enter_copy_.end()) //{

  // ret = (*iter).live_time_;

  //}

#include <vector>

#include <string>

#include <map>

#include <iostream>

#include <algorithm>

#include <boost/bind.hpp>

#include <boost/ptr_container/ptr_vector.hpp>

#include <boost/ptr_container/ptr_map.hpp>

struct my_class

{

 my_class()

 {

  std::cout << "my_class()" << std::endl;

 }

 ~my_class()

 {

  std::cout << "~my_class()" << std::endl;

 }

 my_class(const my_class& other)

 {

  a_ = other.a_;

  b_ = other.b_;

  std::cout << "(const my_class& other)" << std::endl;

  //return *this;

 }

 my_class & operator = (const my_class& rhs)

 {

  a_ = rhs.a_;

  b_ = rhs.b_;

  std::cout << "my_class & operator =" << std::endl;

  return *this;

 }

 int a_;

 int b_;

};

int main()

{

 boost::ptr_vector< my_class > vec;

 std::map<int, boost::ptr_vector< my_class > > mp;

 {

  my_class *my1 = new my_class();

  my1->a_ = 1;

  my1->b_ = 2;

  vec.push_back(my1);

  my_class *my2 = new my_class();

  my2->a_ = 11;

  my2->b_ = 22;

  vec.push_back(my2);

 }

 mp.insert(std::make_pair(1,vec));

 int index = 0;

 for(auto iter = mp.begin(); iter != mp.end(); ++iter)

 {

  for(auto i = (*iter).second.begin(); i != (*iter).second.end(); ++i, ++index)

   std::cout << "a_: " << (*iter).second.at(index).a_ << "b_: " << (*iter).second.at(index).b_ << std::endl;;

 }

}

#include <iostream>
#include <vector>
#include <algorithm>
#include <boost/iterator/indirect_iterator.hpp>
#include <boost/bind.hpp>


using namespace std;


struct Element
{
int a;
int b;
};


class my_test
{
public:
my_test()
{


}

void ReferenceFn( Element & e );


void PointerFn( Element * e );


void Function();


void fn(int a, int b)
{
cout << a << b << endl;
}


void fn1()
{
vector< int > vec;
vec.push_back( 1 );
vec.push_back( 2 );
vec.push_back( 3 );


std::for_each(
vec.begin(), 
vec.end(), 
boost::bind(&my_test::fn, this, 5, _1)
);
}
};


void my_test::ReferenceFn( Element & e ) {  }


void my_test::PointerFn( Element * e ) { }


void my_test::Function()
{
std::vector< Element * > elements;
// add some elements...


// This works, as the argument is a pointer type
std::for_each( elements.begin(), elements.end(),
boost::bind( &my_test::PointerFn, boost::ref(*this), _1 ) );


// This fails (compiler error), as the argument is a reference type
//std::for_each( elements.begin(), elements.end(),
// boost::bind( &my_test::ReferenceFn, boost::ref(*this), _1 ) );


std::for_each( boost::make_indirect_iterator(elements.begin()), 
               boost::make_indirect_iterator(elements.end()),
               boost::bind( &my_test::ReferenceFn, boost::ref(*this), _1 ) );
}
int main()
{
my_test test;
test.fn1();


return 0;
}