Funkcja boost::bind jest generalizacją funkcji std::bind1st i std::bind2nd dostępnych w bibliotece standardowej. Funkcja ta wspiera funktory, funkcje, wskaźniki do funkcji oraz wskaźniki do funkcji składowych. Jest w stanie związać dowolny argument ze specyficzną wartością albo przekierować argumenty wejściowe we wskazane pozycje. boost::bind nie nakłada żadnych wymagań obiektom funkcyjnym, w ogólności nie wymaga standardowych definicji typów takich jak: result_type, first_argument_type, second_argument_type.
Do korzystania z funcji boost::bind konieczne jest dołączenie nagłówka boost/bind.hpp.
Zacznijmy od stworzenia dwóch prostych funkcji.
int g(int a, int b) { return a + b; } void f(int i1,int i2,int i3,int i4, int i5,int i6,int i7,int i8, int i9) { std::cout << i1 << i2 << i3 << i4 << i5 << i6 << i7 << i8 << i9 << '\n'; }
Najprostszym przypadkiem użycia boost::bind jest stworzenie bezargumentowego funktora przez zastąpienie argumentów funkcji wartościami stałymi.
bind(g, 1, 2); //utworzony tutaj funktor ze stałymi arumentami odpowiada g(1, 2);
Jako pierwszy argument boost::bind podajemy wskaźnik do funkcji, następne dwa przypisywane są jako pierwszy i drugi argument funkcji g. Typ zwracany przez funktor jest identyczny z typem zwracanym przez funkcję podaną jako pierwszy argument.
Znacznie ciekawszym mechanizmem jest możliwość selektywnego zastępowania argumentów lub kolejności przekazywanych argumentów.
int main() { int i1=1,i2=2,i3=3,i4=4,i5=5,i6=6,i7=7,i8=8,i9=9; boost::bind(f,_9,_2,_1,_6,_3,_8,_4,_5,_7) //utworzenie tymczasowego funktora i wywołanie (i1,i2,i3,i4,i5,i6,i7,i8,i9); //odpowiadające wywołaniu f(i9, i2, i1, i6, i3, i8, i4, i5, i7) //w wyniku otrzymamy ciąg: 921638457 return 0; }
Realizujemy to za pomocą symbli zastępczych oznaczanych jako _1, _2, …, _9. Dostępnych mamy łacznie 9 takich symboli. Ogranicza to możliwośc tworzenia funktorów do funktorów 9 elementowych (w przypadku funkcji składowych jest to 8 argumentów; musimy pamietć o przekazaniu obiektu na rzecz, którego będzie wywoływany funktor). Symbol _1 oznacza „zastąp przez pierwszy argument wejściowy”, analogicznie pozostałe osiem.
Argumenty można dowolnie zamieniać ze stałymi jak i zamieniać ich kolejność.
boost::bind nie jest ograniczony tylko do wskaźników do funkcji, akceptuje min. również funktory. W przypadku użycia funktora zazwyczaj należy jawnie podać typ zwracany przez operator() funktora (ewentualnie zdefinjować typ result_type w funktorze).
struct Foo { int operator()(int a, int b) { return a - b; } bool operator()(long a, long b) { return a == b; } }; Foo f; int x = 1024; bind<int>(f, _1, _1)(x); //wywołanie f(x, x), wynik 0
Niektóre kompilatory mają problem ze składnią w postaci bind<R>(…). Wyrażenie to można zastąpić postacią alternatwną.
boost::bind(boost::type<int>(), f, _1, _1)(x);
Wskaźniki do metod i danych sładowych nie są obiektami funkcyjnymi, ponieważ nie wspierają operatora operator(). Dla wygody boost::bind akceptuje te wskażniki jako pierwszy argument. boost::bind używa funkcji boost::mem_fn do konwersji wskźników do składowych na funktory. Innymi słowami, wyrażenie:
bind(&Foo::f, args)
odpowiada
bind<R>(mem_fn(&Foo::f), args)
gdzie R jest typem zwracanym przez Foo::f w przypadku metod lub typem danych w przypadku danych składowych.
Przykład:
struct Foo { bool f(int a); }; Foo x; shared_ptr<Foo> p(new Foo); int i = 5; bind(&Foo::f, boost::ref(x), _1)(i); // x.f(i) bind(&Foo::f, &x, _1)(i); //(&x)->f(i) bind(&Foo::f, x, _1)(i); //(wewnętrzna kopja x).f(i) bind(&Foo::f, p, _1)(i); //(wewnętrzna kopja p)->f(i)
Jako drugi argument boost::bind przekazujemy obiekt klasy na rzecz, której ma być wywoływana funkcja (jest to oczywiste, jeśli zauważymy, że pierwszym niejawnym argumentem metod jest zawsze wskaźnik this - adres obiektu). Najciekawsze są dwie ostatnie linijki przykładu. bind(&Foo::f, x, _1) przechowuje wewnętrzną kopję obieku x (warto zwrócić na to uwagę, szczególnie gdy kopjowanie obiektu jest kosztowne), natomiast bind(&Foo::f, p, _1) kopję wskażnika p (p jest sprytnym wskaźnikiem shared_ptr<>), tworzony obiekt funkcyjny przechowuje swoją referencję do instancji klasy Foo i będzie ona poprawna nawet kiedy p wyjdzie poza zasięg lub wykonamy na p reset().
Funcję boost::bind można też bezprolemowo użyć z funkcjami wirtualnymi.
class base { public: virtual void print() const { std::cout << "base!\n"; } virtual ~base() {} }; class derived : public base { public: void print() const { std::cout << "derived!\n"; } }; int main() { derived d; base b; base* bp = &d; boost::bind(&base::print, _1)(b); boost::bind(&base::print, _1)(bp); boost::bind(&base::print, _1)(d); return 0; }
Wynikiem będzie oczekiwany ciąg:
base! derived! derived!
Część argumentów przekazywanych bind może być zagnieżdżonymi wyrażeniami boost::bind.
bind(f, bind(g, _1))(x); //f(g(x))
Wewnętrzne wyrażenia są ewaluowane w bliżej nie okreśłonej kolejności, ale przed wywołaniem funktora zewnętzrnego boost::bind. Odnosząc się do przykładu, kiedy utworzony funktor jest wywoływany z argumentem x, w pierwszej kolejności ewalowany jest bind(g, _1)(x), dając g(x), następnie bind(f, g(x))(x), dając finalny wynik w postaci wywołania f(g(x)).
Ta cecha boost::bind może być bardzo dobrze zastosowana do kompozycji funkcji.
Trzeba zaznaczyć, że pierwszy argument boost::bind (opakowywany obiekt funkcyjny) nie jest ewalowany, nawet wtedy, kiedy jest to obiekt funkcyjny produkowany przez zagnieżdżone wywołanie bind lub argument w postaci symbola zastępczego. Poniższy przykład nie będzie działał tak, jakbyśmy tego oczekiwali.
typedef void (*fp)(int); std::vector<fp> v; std::for_each(v.begin(), v.end(), bind(_1, 5));
Oczekiwany efekt uzyskamy korzystając z pomocniczego obiektu funkcyjnego apply (implementacja apply w boost/bind/apply.hpp), który podajemy jako pierwszy argument boost::bind. Poprzedni przykład powinien wyglądać następująco.
typedef void (*fp)(int); std::vector<fp> v; std::for_each(v.begin(), v.end(), bind(apply<void>(), _1, 5));
Używając bind można komponować funkcje korzystając naraz z boost::bind i funkcji (algorytmów) z biblioteki standardowej.
std::vector<int> ints; ints.push_back(7); ints.push_back(4); ints.push_back(12); ints.push_back(10); int count=std::count_if( ints.begin(), ints.end(), boost::bind( std::logical_and<bool>(), boost::bind(std::greater<int>(),_1,5), boost::bind(std::less_equal<int>(),_1,10))); std::cout << count << '\n'; std::vector<int>::iterator int_it = std::find_if( ints.begin(), ints.end(), boost::bind(std::logical_and<bool>(), boost::bind(std::greater<int>(),_1,5), boost::bind(std::less_equal<int>(),_1,10))); if (int_it != ints.end()) { std::cout << *int_it << '\n'; }
Jak widać na przykładzie łatwo można tworzyć złożone predykaty. Często trzeba się jednak często zastanowić, czy stosować bardzo złożone wyrażenia. Utrudniają one późniejszą analizę kodu, często wręcz uniemożliwiają. Warto rozważyć w takich przypadkach zdefinjowanie funktora lub operatora operator() dla klasy.
Funktor zwracany przez boost::bind można przypisać do obiektu funkcyjnego boos::function. W ten sposób można między innymi przechowywć wcześniej utworzone fukntory jako zmienne i pola klasy albo przekazywać je jako argument do konstruktorów lub funkcji. Przypisania możemy dokonać wykłym operatorem =.
double Foo(double x, double y) { return x + y; } boost::function<double(double)> f = boost::bind(Foo, _1, y); //tworzymy funktor przyjmujący jeden argument //i przypisujemy go do obiektu funkcyjnego
Warunkiem poprawnej kompilacji jest dokładne określenie typu szablonu obiektu function (zasada działania boost::function wykracza poza ten artykuł).
Przeciązone operatory dla boost::bind pojawiły się w Boost 1.33
Obiekty funkcyjne produkowane przez boost::bind przeciążają logiczny operator przecenia ! oraz operatory relacji ==, !=, <, ⇐, >, >=.
!bind(f, ...)
Jest ekwiwalentem
bind(logical_not(), bind(f, ...))
gdzie logical_not jest funktorem przyjmującym jeden argument x i zwracający !x.
bind(f, ...) op x
op jest operatorem relacji, wyrażniu temu odpowiada
bind(relation(), bind(f, ...), x)
gdzie relation jest funktorem przyjmującym dwa argumenty a i b oraz zwracającym a op b.
Przeciążenie tych operatorów umożliwia na konwencjonalne negowanie wyniku boost::bind:
std::remove_if(first, last, !bind(&X::foo, _1)); //usun obiekt nie spełniający jakiegoś warunku
oraz na porównywanie wyników boost::bind z wartościami:
std::find_if(first, last, bind(&X::name, _1) == "xyz");
ze znakiem zastępczym:
bind(&X::name, _1) == _2
albo z innym wyrażeniem boost::bind:
std::sort(first, last, bind(&X::name, _1) < bind(&X::name, _2));
boost::bind umożliwia w przeciwnieństwie do funkcji z biblioteki standardowej (służących do tworzenia adpterów funkcji) bardzo elastyczną pracę z kodem.
#include <iostream> #include <string> #include <boost/bind.hpp> class status { std::string name_; bool ok_; public: status(const std::string& name):name_(name),ok_(true) {} void break_it() { ok_=false; } bool is_broken() const { return ok_; } void report() const { std::cout << name_ << " is " << (ok_ ? "working nominally":"terribly broken") << '\n'; } }; int main() { std::vector<status*> statuses; statuses.push_back(new status("status 1")); statuses.push_back(new status("status 2")); statuses.push_back(new status("status 3")); statuses.push_back(new status("status 4")); statuses[1]->break_it(); statuses[2]->break_it(); std::for_each( statuses.begin(), statuses.end(), boost::bind(&status::report, _1)); return 0; }
Jeśli w pewnym momencie pisania projektu postanowimy używać wektora wskaźników do obiektów zamiast wektora obiektów lub sprytnych wskaźników w przypadku bind musimy zmienić tylko moment tworzenia obiektów, na przykład:
std::vector<boost::shared_ptr<status> > statuses; statuses.push_back( boost::shared_ptr<status>(new status("status 1"))); statuses.push_back( boost::shared_ptr<status>(new status("status 2"))); statuses.push_back( boost::shared_ptr<status>(new status("status 3"))); statuses.push_back( boost::shared_ptr<status>(new status("status 4")));
Użycie funkcji standardowych (std::mem_fun_ref i std::mem_fun) zmusza do zmian także pętli for_each po każdej modyfikacji typu przechowywanego przez wektor, a nawet uniemożliwia dalszą pracę (brak obsługi w przypadku użycia sprytnych wskaźników).
— Maciej Płachta H1ISI