Ответ 1

Примечание. Большинство ответов касаются указателей на функции, что является одной из возможностей достижения логики "обратного вызова" в C++, но на сегодняшний день, я думаю, не самый благоприятный.

Что такое обратные вызовы (?) И зачем их использовать (!)

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

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

Многие функции библиотеки стандартных алгоритмов <algorithm> используют обратные вызовы. Например, алгоритм for_each применяет унарный обратный вызов к каждому элементу в диапазоне итераторов:

template<class InputIt, class UnaryFunction>
UnaryFunction for_each(InputIt first, InputIt last, UnaryFunction f)
{
  for (; first != last; ++first) {
    f(*first);
  }
  return f;
}

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

std::vector<double> v{ 1.0, 2.2, 4.0, 5.5, 7.2 };
double r = 4.0;
std::for_each(v.begin(), v.end(), [&](double & v) { v += r; });
std::for_each(v.begin(), v.end(), [](double v) { std::cout << v << " "; });

который печатает

5 6.2 8 9.5 11.2

Другое применение обратных вызовов - это уведомление вызывающих абонентов об определенных событиях, что обеспечивает определенную гибкость статического времени/времени компиляции.

Лично я использую локальную библиотеку оптимизации, которая использует два разных обратных вызова:

• Первый обратный вызов вызывается, если требуется значение функции и градиент, основанный на векторе входных значений (логический обратный вызов: определение значения функции/получение градиента).
• Второй обратный вызов вызывается один раз для каждого шага алгоритма и получает определенную информацию о сходимости алгоритма (обратный вызов уведомления).

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

Кроме того, обратные вызовы могут включать динамическое поведение во время выполнения.

Представьте себе некоторый класс игрового движка, у которого есть функция, которая запускается каждый раз, когда пользователь нажимает кнопку на его клавиатуре, и набор функций, которые управляют вашим игровым поведением. С помощью обратных вызовов вы можете (пере) решить во время выполнения, какое действие будет предпринято.

void player_jump();
void player_crouch();

class game_core
{
    std::array<void(*)(), total_num_keys> actions;
    // 
    void key_pressed(unsigned key_id)
    {
        if(actions[key_id]) actions[key_id]();
    }
    // update keybind from menu
    void update_keybind(unsigned key_id, void(*new_action)())
    {
        actions[key_id] = new_action;
    }
};

Здесь функция key_pressed использует обратные вызовы, сохраненные в actions чтобы получить желаемое поведение при нажатии определенной клавиши. Если игрок решает изменить кнопку прыжка, двигатель может вызвать

game_core_instance.update_keybind(newly_selected_key, &player_jump);

и, таким образом, изменить поведение вызова на key_pressed (который вызывает player_jump) после нажатия этой кнопки в следующий раз в игре.

Что называют в C++ (11)?

См. Концепции C++: Callable on cppreference для более формального описания.

Функция обратного вызова может быть реализована несколькими способами в C++ (11), так как несколько разных вещей могут быть вызваны *:

• Указатели на функции (включая указатели на функции-члены)
• объекты std::function
• Лямбда-выражения
• Привязка выражений
• Объекты функций (классы с перегруженными функциями, оператор вызова operator())

_{* Примечание: указатель на элементы данных также может быть вызван, но функция не вызывается вообще.}

Несколько важных способов написать обратные вызовы в деталях

• X.1 "Написание" обратного вызова в этом посте означает синтаксис для объявления и присвоения имени типу обратного вызова.
• X.2 "Вызов" обратного вызова относится к синтаксису для вызова этих объектов.
• X.3 "Использование" обратного вызова означает синтаксис при передаче аргументов функции с использованием обратного вызова.

Примечание. Начиная с C++ 17, вызов типа f(...) может быть записан как std::invoke(f,...) который также обрабатывает указатель на регистр члена.

1. Функциональные указатели

Указатель на функцию - это "самый простой" (с точки зрения универсальности; с точки зрения читабельности, возможно, наихудший) тип, который может иметь обратный вызов.

Пусть есть простая функция foo:

int foo (int x) { return 2+x; }

1.1 Написание указателя функции/обозначения типа

Тип указателя на функцию имеет обозначение

return_type (*)(parameter_type_1, parameter_type_2, parameter_type_3)
// i.e. a pointer to foo has the type:
int (*)(int)

где тип указателя на именованную функцию будет выглядеть

return_type (* name) (parameter_type_1, parameter_type_2, parameter_type_3)

// i.e. f_int_t is a type: function pointer taking one int argument, returning int
typedef int (*f_int_t) (int); 

// foo_p is a pointer to function taking int returning int
// initialized by pointer to function foo taking int returning int
int (* foo_p)(int) = &foo; 
// can alternatively be written as 
f_int_t foo_p = &foo;

Объявление using дает нам возможность сделать вещи немного более читабельными, поскольку typedef для f_int_t также можно записать так:

using f_int_t = int(*)(int);

Где (по крайней мере, для меня) более f_int_t что f_int_t - это псевдоним нового типа, и распознавание типа указателя на функцию также легче

И объявление функции, использующей обратный вызов типа указателя на функцию, будет:

// foobar having a callback argument named moo of type 
// pointer to function returning int taking int as its argument
int foobar (int x, int (*moo)(int));
// if f_int is the function pointer typedef from above we can also write foobar as:
int foobar (int x, f_int_t moo);

1.2 Обратный звонок

Нотация вызова соответствует простому синтаксису вызова функции:

int foobar (int x, int (*moo)(int))
{
    return x + moo(x); // function pointer moo called using argument x
}
// analog
int foobar (int x, f_int_t moo)
{
    return x + moo(x); // function pointer moo called using argument x
}

1.3 Обратный звонок использовать нотацию и совместимые типы

Функция обратного вызова, принимающая указатель на функцию, может быть вызвана с помощью указателей на функцию.

Использовать функцию, которая принимает обратный вызов указателя функции, довольно просто:

 int a = 5;
 int b = foobar(a, foo); // call foobar with pointer to foo as callback
 // can also be
 int b = foobar(a, &foo); // call foobar with pointer to foo as callback

1.4 Пример

Можно написать функцию, которая не зависит от того, как работает обратный вызов:

void tranform_every_int(int * v, unsigned n, int (*fp)(int))
{
  for (unsigned i = 0; i < n; ++i)
  {
    v[i] = fp(v[i]);
  }
}

где возможные обратные вызовы могут быть

int double_int(int x) { return 2*x; }
int square_int(int x) { return x*x; }

используется как

int a[5] = {1, 2, 3, 4, 5};
tranform_every_int(&a[0], 5, double_int);
// now a == {2, 4, 6, 8, 10};
tranform_every_int(&a[0], 5, square_int);
// now a == {4, 16, 36, 64, 100};

2. Указатель на функцию-член

Указатель на функцию-член (некоторого класса C) - это специальный тип (и даже более сложный) указателя на функцию, для которого требуется объект типа C для работы.

struct C
{
    int y;
    int foo(int x) const { return x+y; }
};

2.1 Запись указателя на функцию-член/нотацию типа

Указатель на тип функции-члена для некоторого класса T имеет обозначение

// can have more or less parameters
return_type (T::*)(parameter_type_1, parameter_type_2, parameter_type_3)
// i.e. a pointer to C::foo has the type
int (C::*) (int)

где именованный указатель на функцию-член будет -in аналогично функции pointer- выглядеть следующим образом:

return_type (T::* name) (parameter_type_1, parameter_type_2, parameter_type_3)

// i.e. a type 'f_C_int' representing a pointer to member function of 'C'
// taking int returning int is:
typedef int (C::* f_C_int_t) (int x); 

// The type of C_foo_p is a pointer to member function of C taking int returning int
// Its value is initialized by a pointer to foo of C
int (C::* C_foo_p)(int) = &C::foo;
// which can also be written using the typedef:
f_C_int_t C_foo_p = &C::foo;

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

// C_foobar having an argument named moo of type pointer to member function of C
// where the callback returns int taking int as its argument
// also needs an object of type c
int C_foobar (int x, C const &c, int (C::*moo)(int));
// can equivalently declared using the typedef above:
int C_foobar (int x, C const &c, f_C_int_t moo);

2.2 Обратный звонок

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

int C_foobar (int x, C const &c, int (C::*moo)(int))
{
    return x + (c.*moo)(x); // function pointer moo called for object c using argument x
}
// analog
int C_foobar (int x, C const &c, f_C_int_t moo)
{
    return x + (c.*moo)(x); // function pointer moo called for object c using argument x
}

Примечание: если указатель на C доступен, синтаксис эквивалентен (где указатель на C должен быть разыменован):

int C_foobar_2 (int x, C const * c, int (C::*meow)(int))
{
    if (!c) return x;
    // function pointer meow called for object *c using argument x
    return x + ((*c).*meow)(x); 
}
// or equivalent:
int C_foobar_2 (int x, C const * c, int (C::*meow)(int))
{
    if (!c) return x;
    // function pointer meow called for object *c using argument x
    return x + (c->*meow)(x); 
}

2.3 Обратный звонок использовать нотацию и совместимые типы

Функция обратного вызова, принимающая указатель на функцию-член класса T может быть вызвана с использованием указателя на функцию-член класса T

Использование функции, которая получает указатель на обратный вызов функции-члена, также является -in аналогом функции pointers-:

 C my_c{2}; // aggregate initialization
 int a = 5;
 int b = C_foobar(a, my_c, &C::foo); // call C_foobar with pointer to foo as its callback

3. std::function objects (заголовок <functional>)

Класс std::function является полиморфной функцией-оберткой для хранения, копирования или вызова вызываемых объектов.

3.1 Написание std::function объекта/обозначения типа

Тип объекта std::function хранящего вызываемый объект, выглядит следующим образом:

std::function<return_type(parameter_type_1, parameter_type_2, parameter_type_3)>

// i.e. using the above function declaration of foo:
std::function<int(int)> stdf_foo = &foo;
// or C::foo:
std::function<int(const C&, int)> stdf_C_foo = &C::foo;

3.2 Обратный звонок

В классе std::function operator() который можно использовать для вызова своей цели.

int stdf_foobar (int x, std::function<int(int)> moo)
{
    return x + moo(x); // std::function moo called
}
// or 
int stdf_C_foobar (int x, C const &c, std::function<int(C const &, int)> moo)
{
    return x + moo(c, x); // std::function moo called using c and x
}

3.3 Обратный звонок использовать нотацию и совместимые типы

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

3.3.1 Указатели на функции и указатели на функции-члены

Указатель на функцию

int a = 2;
int b = stdf_foobar(a, &foo);
// b == 6 ( 2 + (2+2) )

или указатель на функцию-член

int a = 2;
C my_c{7}; // aggregate initialization
int b = stdf_C_foobar(a, c, &C::foo);
// b == 11 == ( 2 + (7+2) )

может быть использован.

3.3.2 Лямбда-выражения

Безымянное замыкание из лямбда-выражения может храниться в объекте std::function:

int a = 2;
int c = 3;
int b = stdf_foobar(a, [c](int x) -> int { return 7+c*x; });
// b == 15 ==  a + (7*c*a) == 2 + (7+3*2)

3.3.3 выражения std::bind

Результат выражения std::bind может быть передан. Например, связывая параметры с вызовом указателя функции:

int foo_2 (int x, int y) { return 9*x + y; }
using std::placeholders::_1;

int a = 2;
int b = stdf_foobar(a, std::bind(foo_2, _1, 3));
// b == 23 == 2 + ( 9*2 + 3 )
int c = stdf_foobar(a, std::bind(foo_2, 5, _1));
// c == 49 == 2 + ( 9*5 + 2 )

Где также объекты могут быть связаны как объект для вызова указателя на функции-члены:

int a = 2;
C const my_c{7}; // aggregate initialization
int b = stdf_foobar(a, std::bind(&C::foo, my_c, _1));
// b == 1 == 2 + ( 2 + 7 )

3.3.4 Функциональные объекты

Объекты классов, имеющих надлежащую перегрузку operator() могут храниться внутри объекта std::function.

struct Meow
{
  int y = 0;
  Meow(int y_) : y(y_) {}
  int operator()(int x) { return y * x; }
};
int a = 11;
int b = stdf_foobar(a, Meow{8});
// b == 99 == 11 + ( 8 * 11 )

3.4 Пример

Изменение примера указателя на функцию для использования std::function

void stdf_tranform_every_int(int * v, unsigned n, std::function<int(int)> fp)
{
  for (unsigned i = 0; i < n; ++i)
  {
    v[i] = fp(v[i]);
  }
}

дает намного больше полезности для этой функции, потому что (см. 3.3) у нас есть больше возможностей использовать ее:

// using function pointer still possible
int a[5] = {1, 2, 3, 4, 5};
stdf_tranform_every_int(&a[0], 5, double_int);
// now a == {2, 4, 6, 8, 10};

// use it without having to write another function by using a lambda
stdf_tranform_every_int(&a[0], 5, [](int x) -> int { return x/2; });
// now a == {1, 2, 3, 4, 5}; again

// use std::bind :
int nine_x_and_y (int x, int y) { return 9*x + y; }
using std::placeholders::_1;
// calls nine_x_and_y for every int in a with y being 4 every time
stdf_tranform_every_int(&a[0], 5, std::bind(nine_x_and_y, _1, 4));
// now a == {13, 22, 31, 40, 49};

4. Шаблонный тип обратного вызова

Используя шаблоны, код, вызывающий обратный вызов, может быть даже более общим, чем использование объектов std::function.

Обратите внимание, что шаблоны являются функцией времени компиляции и инструментом дизайна для полиморфизма времени компиляции. Если динамическое поведение во время выполнения должно быть достигнуто с помощью обратных вызовов, шаблоны помогут, но они не будут вызывать динамику во время выполнения.

4.1 Написание (обозначения типа) и вызов шаблонных обратных вызовов

Обобщение, т.е. приведенный std_ftransform_every_int код std_ftransform_every_int может быть еще более достигнуто с помощью шаблонов:

template<class R, class T>
void stdf_transform_every_int_templ(int * v,
  unsigned const n, std::function<R(T)> fp)
{
  for (unsigned i = 0; i < n; ++i)
  {
    v[i] = fp(v[i]);
  }
}

с еще более общим (а также самым простым) синтаксисом для типа обратного вызова, являющегося простым, подлежащим выводу шаблонным аргументом:

template<class F>
void transform_every_int_templ(int * v, 
  unsigned const n, F f)
{
  std::cout << "transform_every_int_templ<" 
    << type_name<F>() << ">\n";
  for (unsigned i = 0; i < n; ++i)
  {
    v[i] = f(v[i]);
  }
}

Примечание: включенный вывод печатает имя типа, выведенное для шаблонного типа F Реализация type_name приведена в конце этого поста.

Наиболее общая реализация для унарного преобразования диапазона является частью стандартной библиотеки, а именно std::transform, которая также шаблонируется в отношении повторяющихся типов.

template<class InputIt, class OutputIt, class UnaryOperation>
OutputIt transform(InputIt first1, InputIt last1, OutputIt d_first,
  UnaryOperation unary_op)
{
  while (first1 != last1) {
    *d_first++ = unary_op(*first1++);
  }
  return d_first;
}

4.2 Примеры использования шаблонных обратных вызовов и совместимых типов

Совместимые типы для шаблонного метода обратного вызова std::function stdf_transform_every_int_templ идентичны вышеупомянутым типам (см. 3.4).

Однако при использовании шаблонной версии сигнатура используемого обратного вызова может немного измениться:

// Let
int foo (int x) { return 2+x; }
int muh (int const &x) { return 3+x; }
int & woof (int &x) { x *= 4; return x; }

int a[5] = {1, 2, 3, 4, 5};
stdf_transform_every_int_templ<int,int>(&a[0], 5, &foo);
// a == {3, 4, 5, 6, 7}
stdf_transform_every_int_templ<int, int const &>(&a[0], 5, &muh);
// a == {6, 7, 8, 9, 10}
stdf_transform_every_int_templ<int, int &>(&a[0], 5, &woof);

Примечание: std_ftransform_every_int (не шаблонная версия; см. Выше) работает с foo но не использует muh.

// Let
void print_int(int * p, unsigned const n)
{
  bool f{ true };
  for (unsigned i = 0; i < n; ++i)
  {
    std::cout << (f ? "" : " ") << p[i]; 
    f = false;
  }
  std::cout << "\n";
}

Простой шаблонный параметр transform_every_int_templ может быть любым возможным вызываемым типом.

int a[5] = { 1, 2, 3, 4, 5 };
print_int(a, 5);
transform_every_int_templ(&a[0], 5, foo);
print_int(a, 5);
transform_every_int_templ(&a[0], 5, muh);
print_int(a, 5);
transform_every_int_templ(&a[0], 5, woof);
print_int(a, 5);
transform_every_int_templ(&a[0], 5, [](int x) -> int { return x + x + x; });
print_int(a, 5);
transform_every_int_templ(&a[0], 5, Meow{ 4 });
print_int(a, 5);
using std::placeholders::_1;
transform_every_int_templ(&a[0], 5, std::bind(foo_2, _1, 3));
print_int(a, 5);
transform_every_int_templ(&a[0], 5, std::function<int(int)>{&foo});
print_int(a, 5);

Приведенный выше код печатает:

1 2 3 4 5
transform_every_int_templ <int(*)(int)>
3 4 5 6 7
transform_every_int_templ <int(*)(int&)>
6 8 10 12 14
transform_every_int_templ <int& (*)(int&)>
9 11 13 15 17
transform_every_int_templ <main::{lambda(int)#1} >
27 33 39 45 51
transform_every_int_templ <Meow>
108 132 156 180 204
transform_every_int_templ <std::_Bind<int(*(std::_Placeholder<1>, int))(int, int)>>
975 1191 1407 1623 1839
transform_every_int_templ <std::function<int(int)>>
977 1193 1409 1625 1841

реализация type_name использованная выше

#include <type_traits>
#include <typeinfo>
#include <string>
#include <memory>
#include <cxxabi.h>

template <class T>
std::string type_name()
{
  typedef typename std::remove_reference<T>::type TR;
  std::unique_ptr<char, void(*)(void*)> own
    (abi::__cxa_demangle(typeid(TR).name(), nullptr,
    nullptr, nullptr), std::free);
  std::string r = own != nullptr?own.get():typeid(TR).name();
  if (std::is_const<TR>::value)
    r += " const";
  if (std::is_volatile<TR>::value)
    r += " volatile";
  if (std::is_lvalue_reference<T>::value)
    r += " &";
  else if (std::is_rvalue_reference<T>::value)
    r += " &&";
  return r;
}

Ответ 2

Существует также способ C выполнять обратные вызовы: указатели на функции

//Define a type for the callback signature,
//it is not necessary, but makes life easier

//Function pointer called CallbackType that takes a float
//and returns an int
typedef int (*CallbackType)(float);  


void DoWork(CallbackType callback)
{
  float variable = 0.0f;

  //Do calculations

  //Call the callback with the variable, and retrieve the
  //result
  int result = callback(variable);

  //Do something with the result
}

int SomeCallback(float variable)
{
  int result;

  //Interpret variable

  return result;
}

int main(int argc, char ** argv)
{
  //Pass in SomeCallback to the DoWork
  DoWork(&SomeCallback);
}

Теперь, если вы хотите передать методы класса в качестве обратных вызовов, объявления этих указателей функций имеют более сложные объявления, например:

//Declaration:
typedef int (ClassName::*CallbackType)(float);

//This method performs work using an object instance
void DoWorkObject(CallbackType callback)
{
  //Class instance to invoke it through
  ClassName objectInstance;

  //Invocation
  int result = (objectInstance.*callback)(1.0f);
}

//This method performs work using an object pointer
void DoWorkPointer(CallbackType callback)
{
  //Class pointer to invoke it through
  ClassName * pointerInstance;

  //Invocation
  int result = (pointerInstance->*callback)(1.0f);
}

int main(int argc, char ** argv)
{
  //Pass in SomeCallback to the DoWork
  DoWorkObject(&ClassName::Method);
  DoWorkPointer(&ClassName::Method);
}

Ответ 3

Скотт Мейерс дает хороший пример:

class GameCharacter;
int defaultHealthCalc(const GameCharacter& gc);

class GameCharacter
{
public:
  typedef std::function<int (const GameCharacter&)> HealthCalcFunc;

  explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc)
  : healthFunc(hcf)
  { }

  int healthValue() const { return healthFunc(*this); }

private:
  HealthCalcFunc healthFunc;
};

Я думаю, что пример говорит все.

std::function<> - это "современный" способ написания обратных вызовов С++.

Ответ 4

A Функция обратного вызова - это метод, который передается в подпрограмму и вызывается в какой-то момент подпрограммой, к которой он передан.

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

Например, если вы хотите работать с файлами в папке - вы можете вызвать функцию API, используя свою собственную процедуру, и ваша процедура запускается один раз для каждого файла в указанной папке. Это позволяет API быть очень гибким.

Ответ 5

Принятый ответ очень полезен и достаточно всеобъемлющий. Однако состояния OP

Я хотел бы увидеть простой пример, чтобы написать функцию обратного вызова.

Итак, вот вы, из С++ 11 у вас есть std::function, поэтому нет необходимости в указателях функций и подобных материалах:

#include <functional>
#include <string>
#include <iostream>

void print_hashes(std::function<int (const std::string&)> hash_calculator) {
    std::string strings_to_hash[] = {"you", "saved", "my", "day"};
    for(auto s : strings_to_hash)
        std::cout << s << ":" << hash_calculator(s) << std::endl;    
}

int main() {
    print_hashes( [](const std::string& str) {   /** lambda expression */
        int result = 0;
        for (int i = 0; i < str.length(); i++)
            result += pow(31, i) * str.at(i);
        return result;
    });
    return 0;
}

Этот пример, кстати, как-то реальный, потому что вы хотите вызвать функцию print_hashes с различными реализациями хеш-функций, для этой цели я предоставил простой. Он получает строку, возвращает int (хэш-значение предоставленной строки), и все, что вам нужно запомнить из синтаксической части, это std::function<int (const std::string&)>, которая описывает такую ​​функцию, как входной аргумент функции, которая будет вызывать его.

Ответ 6

В С++ нет явной концепции функции обратного вызова. Механизмы обратного вызова часто реализуются с помощью указателей функций, объектов-функторов или объектов обратного вызова. Программисты должны явно разрабатывать и реализовывать функции обратного вызова.

Изменить на основе обратной связи:

Несмотря на отрицательную обратную связь, полученный ответ, это не так. Я постараюсь лучше объяснить, откуда я.

C и С++ имеют все необходимое для реализации функций обратного вызова. Наиболее распространенным и тривиальным способом реализации функции обратного вызова является передача указателя функции в качестве аргумента функции.

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

Например, документация .NET для IFormatProvider говорит, что "GetFormat - это метод обратного вызова", хотя это всего лишь прогон -мезонный интерфейс. Я не думаю, что кто-то будет утверждать, что все вызовы виртуальных методов являются функциями обратного вызова. Что делает метод GetFormat методом обратного вызова не механикой того, как он передается или вызывается, а семантикой вызова вызывающего, который будет вызывать метод GetFormat объекта.

Некоторые языки включают функции с явной семантикой обратного вызова, обычно связанные с событиями и обработкой событий. Например, С# имеет тип события с синтаксисом и семантикой, явно разработанным вокруг концепции обратных вызовов. Visual Basic имеет предложение Handles, которое явно объявляет метод функцией обратного вызова, абстрагируя концепцию делегатов или указателей функций. В этих случаях семантическая концепция обратного вызова интегрируется в сам язык.

C и С++, с другой стороны, не вставляют семантическую концепцию функций обратного вызова почти так же явно. Механизмы существуют, интегрированная семантика - нет. Вы можете реализовать функции обратного вызова просто отлично, но чтобы получить что-то более сложное, которое включает в себя явную семантику обратного вызова, вы должны построить ее поверх того, что предоставляет С++, например, что Qt сделал со своими Сигналы и слоты.

В двух словах, С++ имеет то, что вам нужно для реализации обратных вызовов, часто довольно легко и тривиально с помощью указателей функций. То, что у него нет, - это ключевые слова и функции, чья семантика специфична для обратных вызовов, таких как рейз, emit, Handles, event + = и т.д. Если вы исходите с языка с этими типами элементов, встроенная поддержка обратного вызова в С++ будет чувствовать себя кастрированным.

Ответ 7

Функции обратного вызова являются частью стандарта C, поэтому также являются частью С++. Но если вы работаете с С++, я бы предложил использовать шаблон наблюдателя: http://en.wikipedia.org/wiki/Observer_pattern

Ответ 8

См. приведенное выше определение, в котором указано, что функция обратного вызова передается какой-либо другой функции и в какой-то момент она вызывается.

В С++ желательно, чтобы функции обратного вызова вызывали метод классов. Когда вы это сделаете, у вас есть доступ к данным о членах. Если вы используете способ C для определения обратного вызова, вам нужно будет указать его на статическую функцию-член. Это не очень желательно.

Вот как вы можете использовать обратные вызовы в С++. Предположим, 4 файла. Пара файлов .CPP/.H для каждого класса. Класс C1 - это класс с методом, который мы хотим вызвать. C2 обращается к методу C1. В этом примере функция обратного вызова принимает 1 параметр, который я добавил для читателей. В примере не отображаются объекты, которые создаются и используются. Один вариант использования этой реализации - это когда у вас есть один класс, который считывает и хранит данные во временном пространстве, а другой - обрабатывает данные. С помощью функции обратного вызова для каждой строки данных считывается обратный вызов, после чего он обрабатывается. Этот метод сокращает накладные расходы на требуемое временное пространство. Это особенно полезно для SQL-запросов, которые возвращают большой объем данных, которые затем должны быть обработаны после обработки.

/////////////////////////////////////////////////////////////////////
// C1 H file

class C1
{
    public:
    C1() {};
    ~C1() {};
    void CALLBACK F1(int i);
};

/////////////////////////////////////////////////////////////////////
// C1 CPP file

void CALLBACK C1::F1(int i)
{
// Do stuff with C1, its methods and data, and even do stuff with the passed in parameter
}

/////////////////////////////////////////////////////////////////////
// C2 H File

class C1; // Forward declaration

class C2
{
    typedef void (CALLBACK C1::* pfnCallBack)(int i);
public:
    C2() {};
    ~C2() {};

    void Fn(C1 * pThat,pfnCallBack pFn);
};

/////////////////////////////////////////////////////////////////////
// C2 CPP File

void C2::Fn(C1 * pThat,pfnCallBack pFn)
{
    // Call a non-static method in C1
    int i = 1;
    (pThat->*pFn)(i);
}

Ответ 9

Повышение signals2 позволяет подписаться общие функции - члены (без шаблонов!) И в поточно - образом.

Пример. Сигналы Document-View можно использовать для реализации гибких архитектур Document-View. Документ будет содержать сигнал, к которому может подключиться каждое из представлений. Следующий класс Document определяет простой текстовый документ, который поддерживает несколько представлений. Обратите внимание, что он хранит один сигнал, к которому будут подключены все виды.

class Document
{
public:
    typedef boost::signals2::signal<void ()>  signal_t;

public:
    Document()
    {}

    /* Connect a slot to the signal which will be emitted whenever
      text is appended to the document. */
    boost::signals2::connection connect(const signal_t::slot_type &subscriber)
    {
        return m_sig.connect(subscriber);
    }

    void append(const char* s)
    {
        m_text += s;
        m_sig();
    }

    const std::string& getText() const
    {
        return m_text;
    }

private:
    signal_t    m_sig;
    std::string m_text;
};

Далее мы можем начать определять представления. Следующий класс TextView обеспечивает простое представление текста документа.

class TextView
{
public:
    TextView(Document& doc): m_document(doc)
    {
        m_connection = m_document.connect(boost::bind(&TextView::refresh, this));
    }

    ~TextView()
    {
        m_connection.disconnect();
    }

    void refresh() const
    {
        std::cout << "TextView: " << m_document.getText() << std::endl;
    }
private:
    Document&               m_document;
    boost::signals2::connection  m_connection;
};

Ответ 10

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

void inorder_traversal(Node *p, void *out, void (*callback)(Node *in, void *out))
{
    if (p == NULL)
        return;
    inorder_traversal(p->left, out, callback);
    callback(p, out); // call callback function like this.
    inorder_traversal(p->right, out, callback);
}


// Function like bellow can be used in callback of inorder_traversal.
void foo(Node *t, void *out = NULL)
{
    // You can just leave the out variable and working with specific node of tree. like bellow.
    // cout << t->item;
    // Or
    // You can assign value to out variable like below
    // Mention that the type of out is void * so that you must firstly cast it to your proper out.
    *((int *)out) += 1;
}
// This function use inorder_travesal function to count the number of nodes existing in the tree.
void number_nodes(Node *t)
{
    int sum = 0;
    inorder_traversal(t, &sum, foo);
    cout << sum;
}

 int main()
{

    Node *root = NULL;
    // What These functions perform is inserting an integer into a Tree data-structure.
    root = insert_tree(root, 6);
    root = insert_tree(root, 3);
    root = insert_tree(root, 8);
    root = insert_tree(root, 7);
    root = insert_tree(root, 9);
    root = insert_tree(root, 10);
    number_nodes(root);
}