class image;
class animation
{
public:
    void advance(int ms);
    bool inactive() const;
    void render(image & target) const;
};
std::vector<animation> anims;
template<class C, class P> void erase_if(C & c, P pred)
{
    c.erase(std::remove_if(c.begin(), c.end(), pred), c.end());
}
void update(int ms)
{
    std::for_each(anims.begin(), anims.end(), boost::bind(&animation::advance, _1, ms));
    erase_if(anims, boost::mem_fn(&animation::inactive));
}
void render(image & target)
{
    std::for_each(anims.begin(), anims.end(), boost::bind(&animation::render, _1, boost::ref(target)));
}

class button
{
public:
    boost::function<void()> onClick;
};
class player
{
public:
    void play();
    void stop();
};
button playButton, stopButton;
player thePlayer;
void connect()
{
    playButton.onClick = boost::bind(&player::play, &thePlayer);
    stopButton.onClick = boost::bind(&player::stop, &thePlayer);
}

См. разделУстранение неполадок.

Вероятно, потому, что вы использовали общий синтаксис<bind<R>(f,...)>, тем самым инструктируя<bind>не «инспектировать» f для обнаружения ошибок типа arity и return.

Первая форма предписывает<bind>проверить тип<f>, чтобы определить его аритмию (количество аргументов) и тип возврата. Ошибки Arity будут обнаружены в «связанное время». Этот синтаксис, конечно, предъявляет некоторые требования<f>. Это должна быть функция, указатель функции, указатель функции члена или объект функции, который определяет вложенный тип, названный<result_type>; короче говоря, это должно быть что-то, что<bind>может распознать.

Вторая форма предписывает<bind>не пытаться распознать тип<f>. Обычно он используется с функциональными объектами, которые не выставляют или не могут выставлять<result_type>, но также может использоваться с нестандартными функциями. Например, текущая реализация не распознает автоматически функции с переменными аргументами, такие как<printf>, поэтому вам придется использовать<bind<int>(printf,...)>. Обратите внимание, что альтернативный<bind(type<R>(),f,...)>синтаксис поддерживается по причинам переносимости.

Другим важным фактором, который следует учитывать, является то, что компиляторы без частичной специализации шаблона или поддержки частичного упорядочивания шаблона функции не могут обрабатывать первую форму, когда<f>является объектом функции, и в большинстве случаев не будут обрабатывать вторую форму, когда<f>является функцией (указателем) или указателем функции члена.

Да, если вы<#define BOOST_BIND_ENABLE_STDCALL>. Альтернативой является рассмотрение функции какобщего функционального объектаи использование синтаксиса<bind<R>(f,...)>.

Да, если вы<#define BOOST_MEM_FN_ENABLE_STDCALL>.

Да, если вы<#define BOOST_BIND_ENABLE_PASCAL>. Альтернативой является рассмотрение функции какобщего функционального объектаи использование синтаксиса<bind<R>(f,...)>.

Иногда. На некоторых платформах указатели на внешние функции «С» эквивалентны «обычным» указателям функций, поэтому они работают нормально. Другие платформы рассматривают их как разные типы. Ожидается, что реализация<bind>, ориентированная на конкретную платформу, будет решать проблему прозрачно; эта реализация этого не делает. Как обычно, обходной путь состоит в том, чтобы рассматривать функцию какобщий объект функциии использовать синтаксис<bind<R>(f,...)>.

Непортативные расширения, как правило, должны по умолчанию отключаться, чтобы предотвратить блокировку поставщика. Если бысоответствующие макросыбыли определены автоматически, вы могли бы случайно воспользоваться ими, не понимая, что ваш код, возможно, больше не переносим. Кроме того, некоторые компиляторы имеют возможность сделать<__stdcall><__fastcall>своим стандартом вызова по умолчанию, и в этом случае отдельная поддержка не потребуется.

В выражении<bind(f,a1,a2, ...,aN)>объект функции<f>должен иметь возможность принимать ровно N аргументов. Эта ошибка обычно обнаруживается в «связанное время»; другими словами, ошибка компиляции сообщается в строке, где<bind()>вызывается:

int f(int, int);
int main()
{
    boost::bind(f, 1);    // error, f takes two arguments
    boost::bind(f, 1, 2); // OK
}

Распространенным вариантом этой ошибки является забывание о том, что функции-члены имеют неявный аргумент «это»:

struct X
{
    int f(int);
}
int main()
{
    boost::bind(&X::f, 1);     // error, X::f takes two arguments
    boost::bind(&X::f, _1, 1); // OK
}

Как и в обычных вызовах функции, связанный объект функции должен быть совместим со списком аргументов. Несовместимость обычно обнаруживается компилятором во время вызова, и результатом обычно является ошибка<bind.hpp>в строке, которая выглядит как:

return f(a[a1_], a[a2_]);

Пример такой ошибки:

int f(int);
int main()
{
    boost::bind(f, "incompatible");      // OK so far, no call
    boost::bind(f, "incompatible")();    // error, "incompatible" is not an int
    boost::bind(f, _1);                  // OK
    boost::bind(f, _1)("incompatible");  // error, "incompatible" is not an int
}

Заполнитель<_N>выбирает аргумент в позиции<N>из списка аргументов, прошедшего в «время вызова». Конечно, попытка выйти за пределы этого списка является ошибкой:

int f(int);
int main()
{
    boost::bind(f, _1);                  // OK
    boost::bind(f, _1)();                // error, there is no argument number 1
}

Ошибка обычно сообщается в<bind.hpp>, в строке, аналогичной:

return f(a[a1_]);

При эмуляции<std::bind1st(f,a)>распространенной ошибкой этой категории является тип<bind(f,a,_2)>вместо правильного<bind(f, a,_1)>.

Форма<bind(f,a1,a2, ...,aN)>вызывает автоматическое распознавание типа<f>. Он не будет работать с произвольными функциональными объектами;<f>должен быть функцией или указателем функции члена.

Можно использовать эту форму с функциональными объектами, определяющими<result_type>, но только на компиляторах, поддерживающих частичную специализацию и частичную упорядоченность. В частности, MSVC до версии 7.0 не поддерживает этот синтаксис для функциональных объектов.

Форма<bind<R>(f,a1,a2, ...,aN)>поддерживает произвольные функциональные объекты.

Можно (но не рекомендуется) использовать эту форму с функциями или указателями функций членов, но только на компиляторах, поддерживающих частичную упорядоченность. В частности, MSVC до версии 7.0 не полностью поддерживает этот синтаксис для функций и указателей функций членов.

По умолчанию<bind(f,a1,a2, ...,aN)>формараспознает «обычные» функции C++ и указатели функций.Функции, использующие другую конвенцию вызовов, или функции с переменными аргументами, такие как<std::printf>, не работают. Общая<bind<R>(f,a1,a2, ...,aN)>формаработает с нестандартными функциями.

На некоторых платформах внешние функции «С», такие как<std::strcmp>, не распознаются короткой формой<bind>.

См. также<__stdcall>и<pascal>Поддержка.

Попытка связать перегруженную функцию обычно приводит к ошибке, поскольку нет способа определить, какая перегрузка должна быть связана. Это общая проблема с функциями-членами с двумя перегрузками, как в этом упрощенном примере:

struct X
{
    int& get();
    int const& get() const;
};
int main()
{
    boost::bind(&X::get, _1);
}

Двусмысленность может быть решена вручную, отбрасывая указатель функции (члена) на желаемый тип:

int main()
{
    boost::bind(static_cast< int const& (X::*) () const >(&X::get), _1);
}

Другой, возможно, более читаемой альтернативой является введение временной переменной:

int main()
{
    int const& (X::*get) () const = &X::get;
    boost::bind(get, _1);
}

Объекты функций, которые производятся<bind>, не моделируют понятия STLУнарная функцияилиБинарная функция, даже когда объекты функций являются унарными или двоичными операциями, потому что типы объектов функций не имеют общедоступных типовых значений<result_type>и<argument_type>или<first_argument_type>и<second_argument_type>. Однако в тех случаях, когда эти типдефы желательны, функция полезности<make_adaptable>может быть использована для адаптации объектов унарной и двоичной функций к этим понятиям. Это позволяет комбинировать объекты унарных и двоичных функций, полученные из<bind>, с шаблонами STL, такими как<std::unary_negate>и<std::binary_negate>.

Функция<make_adaptable>определена в<<boost/bind/make_adaptable.hpp>>, которая должна быть включена в дополнение к<<boost/bind.hpp>>:

#include <boost/bind/make_adaptable.hpp>
template <class R, class F> unspecified-type make_adaptable(F f);
template<class R, class A1, class F> unspecified-unary-functional-type make_adaptable(F f);
template<class R, class A1, class A2, class F> unspecified-binary-functional-type make_adaptable(F f);
template<class R, class A1, class A2, class A3, class F> unspecified-ternary-functional-type make_adaptable(F f);
template<class R, class A1, class A2, class A3, class A4, class F> unspecified-4-ary-functional-type make_adaptable(F f);

Этот пример показывает, как использовать<make_adaptable>, чтобы сделать предикат для «не является пространством»:

typedef char char_t;
std::locale loc("");
const std::ctype<char_t>& ct = std::use_facet<std::ctype<char_t> >(loc);
auto isntspace = std::not1(boost::make_adaptable<bool, char_t>(boost::bind(&std::ctype<char_t>::is, &ct, std::ctype_base::space, _1)));

В этом примере<bind>создаётся «пространство» (унитарный) предикат. Затем он передается<make_adaptable>так, что функция объекта моделирует.Унарная функцияможет быть создана как аргумент<std::not1>.

Некоторые компиляторы, в том числе MSVC 6.0 и Borland C++ 5.5.1, имеют проблемы с подписями функций верхнего уровня<const>:

int f(int const);
int main()
{
    boost::bind(f, 1);     // error
}

Обратная сторона: убрать<const>квалификатор из аргумента.

На MSVC (до версии 7.0), когда<boostbind>приведен в действие с помощью декларации:

using boost::bind;

Синтаксис<bind<R>(f,...)>не работает. Обратная сторона: либо используйте квалифицированное имя<boost::bind>, либо используйте вместо этого директиву использования:

using namespace boost;

На MSVC (до версии 7.0) вложенный шаблон класса под названием<bind>будет затенять шаблон функции<boost::bind>, нарушая синтаксис<bind<R>(f,...)>. К сожалению, некоторые библиотеки содержат вложенные шаблоны классов, названные<bind>(по иронии судьбы, такой код часто является специфическим обходным путем MSVC).

Для этого используется альтернативный синтаксис<bind(type<R>(),f,...)>.

MSVC (до версии 7.0) рассматривает эллипс в переменной функции аргумента (например,<std::printf>) как тип. Поэтому он примет (неправильную в текущей реализации) форму:

bind(printf, "%s\n", _1);

Отклонить правильную версию:

bind<int>(printf, "%s\n", _1);

namespace boost
{
// no arguments
template<class R, class F> unspecified-1 bind(F f);
template<class F> unspecified-1-1 bind(F f);
template<class R> unspecified-2 bind(R (*f) ());
// one argument
template<class R, class F, class A1> unspecified-3 bind(F f, A1 a1);
template<class F, class A1> unspecified-3-1 bind(F f, A1 a1);
template<class R, class B1, class A1> unspecified-4 bind(R (*f) (B1), A1 a1);
template<class R, class T, class A1> unspecified-5 bind(R (T::*f) (), A1 a1);
template<class R, class T, class A1> unspecified-6 bind(R (T::*f) () const, A1 a1);
template<class R, class T, class A1> unspecified-6-1 bind(R T::*f, A1 a1);
// two arguments
template<class R, class F, class A1, class A2> unspecified-7 bind(F f, A1 a1, A2 a2);
template<class F, class A1, class A2> unspecified-7-1 bind(F f, A1 a1, A2 a2);
template<class R, class B1, class B2, class A1, class A2> unspecified-8 bind(R (*f) (B1, B2), A1 a1, A2 a2);
template<class R, class T, class B1, class A1, class A2> unspecified-9 bind(R (T::*f) (B1), A1 a1, A2 a2);
template<class R, class T, class B1, class A1, class A2> unspecified-10 bind(R (T::*f) (B1) const, A1 a1, A2 a2);
// implementation defined number of additional overloads for more arguments
}
namespace
{
 unspecified-placeholder-type-1 _1;
 unspecified-placeholder-type-2 _2;
 unspecified-placeholder-type-3 _3;
// implementation defined number of additional placeholder definitions
}

Всенеопределенные-Nтипы, возвращаемые<bind>, являютсяCopyConstructible.неопределенные-N<::result_type>определяется как тип возвратанеопределенные-N<::operator()>.

Все типынеуказанных держателей-NявляютсяCopyConstructible. Их конструкторы копий не бросают исключений.

Функция μ<(x,v1, v2,...,vm)>, где<m>является неотрицательным целым числом, определяется как:

template<class R, class F> unspecified-1 bind(F f)

template<class F> unspecified-1-1 bind(F f)

template<class R> unspecified-2 bind(R (*f) ())

template<class R, class F, class A1> unspecified-3 bind(F f, A1 a1)

template<class F, class A1> unspecified-3-1 bind(F f, A1 a1)

template<class R, class B1, class A1> unspecified-4 bind(R (*f) (B1), A1 a1)

template<class R, class T, class A1> unspecified-5 bind(R (T::*f) (), A1 a1)

template<class R, class T, class A1> unspecified-6 bind(R (T::*f) () const, A1 a1)

template<class R, class T, class A1> unspecified-6-1 bind(R T::*f, A1 a1)

template<class R, class F, class A1, class A2> unspecified-7 bind(F f, A1 a1, A2 a2)

template<class F, class A1, class A2> unspecified-7-1 bind(F f, A1 a1, A2 a2)

template<class R, class B1, class B2, class A1, class A2> unspecified-8 bind(R (*f) (B1, B2), A1 a1, A2 a2)

template<class R, class T, class B1, class A1, class A2> unspecified-9 bind(R (T::*f) (B1), A1 a1, A2 a2)

template<class R, class T, class B1, class A1, class A2> unspecified-10 bind(R (T::*f) (B1) const, A1 a1, A2 a2)

Реализации могут обеспечивать дополнительные<bind>перегрузки для поддержки большего количества аргументов или различных вариаций указателей функций.

Эта реализация поддерживает функциональные объекты до девяти аргументов. Это деталь реализации, а не неотъемлемое ограничение дизайна.

Некоторые платформы допускают несколько типов (член) функций, которые отличаются по своей конвенции вызова (правила, по которым функция вызывается: как передаются аргументы, как обрабатывается возвращаемое значение и кто очищает стек - если таковой имеется).

Например, функции API Windows и функции членов интерфейса COM используют соглашение вызова, известное как<__stdcall>. Компоненты Borland VCL используют<__fastcall>. Функции набора инструментов Mac используют конвенцию вызова<pascal>.

Для использования<bind>с<__stdcall>функциями<#define>макрос<BOOST_BIND_ENABLE_STDCALL>перед включением<<boost/bind.hpp>>.

Для использования<bind>с функциями<__stdcall>,<#define>макрос<BOOST_MEM_FN_ENABLE_STDCALL>перед включением<<boost/bind.hpp>>.

Чтобы использовать<bind>с<__fastcall>функциями,<#define>макрос<BOOST_BIND_ENABLE_FASTCALL>перед включением<<boost/bind.hpp>>.

Для использования<bind>с функциями<__fastcall>,<#define>макрос<BOOST_MEM_FN_ENABLE_FASTCALL>перед включением<<boost/bind.hpp>>.

Для использования<bind>с<pascal>функциями<#define>макрос<BOOST_BIND_ENABLE_PASCAL>перед включением<<boost/bind.hpp>>.

Для использования<bind>с функциями<__cdecl>,<#define>макрос<BOOST_MEM_FN_ENABLE_CDECL>перед включением<<boost/bind.hpp>>.

Лучше всего определить эти макросы в параметрах проекта, через<-D>в командной строке или в качестве первой строки в блоке перевода (файл .cpp), где<bind>используется.Несоблюдение этого правила может привести к неясным ошибкам, когда заголовок включает<bind.hpp>до того, как был определен макрос.

[Примечание:это непортативное расширение. Он не является частью интерфейса.

[Примечание:Некоторые компиляторы обеспечивают только минимальную поддержку ключевого слова<__stdcall>.

Функциональные объекты, возвращаемые<bind>, поддерживают экспериментальный и пока незарегистрированный<visit_each>интерфейс перечисления.

См.bind_visitor.cppдля примера.