Uwaga: Większość odpowiedzi obejmuje Wskaźniki funkcji, które są jedną z możliwości osiągnięcia logiki" callback " w C++, ale na dzień dzisiejszy nie jest to najkorzystniejsza moim zdaniem.

Co to są callbacks (?) i dlaczego ich używać (!)

Wywołanie zwrotne jest wywoływalne (patrz dalej w dół) akceptowane przez klasę lub funkcję, używane do dostosowywania bieżącej logiki w zależności od tego wywołania zwrotnego.

Jednym z powodów użycia callbacks jest napisanie generic kodu, który jest niezależny od logiki w wywołanej funkcji i może być ponownie użyty z różnymi wywołaniami zwrotnymi.

Wiele funkcji standardowej biblioteki algorytmów <algorithm> używa wywołań zwrotnych. Na przykład algorytm for_each stosuje jednoargumentowe wywołanie zwrotne do każdego elementu z zakresu iteratorów:

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

, który może być użyty do przyrostu, a następnie wydruku wektora, przekazując odpowiednie wywołania, na przykład:

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 << " "; });

Które drukuje

5 6.2 8 9.5 11.2

Innym zastosowaniem wywołań zwrotnych jest powiadamianie wywołujących o określonych zdarzeniach, które umożliwia pewną elastyczność czasu statycznego / kompilacji.

Osobiście korzystam z lokalnej biblioteki optymalizacji, która używa dwóch różnych wywołań zwrotnych:]}

• pierwsze wywołanie zwrotne jest wywoływane, jeśli wymagana jest wartość funkcji i gradient na podstawie wektora wartości wejściowych (logic callback: określenie wartości funkcji / wyprowadzenie gradientu).
• drugie wywołanie zwrotne jest wywoływane raz dla każdego kroku algorytmu i otrzymuje pewne informacje o zbieżności algorytmu (callback powiadomień).

Dlatego projektant bibliotek nie jest odpowiedzialny za decydowanie o tym, co dzieje się z informacjami przekazywanymi programiście poprzez callback powiadomień i nie musi się martwić, jak acutally określić wartości funkcji, ponieważ są one dostarczane przez wywołania zwrotnego logiki. Poprawienie tych rzeczy jest zadaniem ze względu na użytkownika biblioteki i utrzymuje bibliotekę szczupłą i bardziej ogólną.

Ponadto wywołania zwrotne mogą włączyć dynamiczne zachowanie środowiska wykonawczego.

Wyobraź sobie jakąś klasę silnika gry, która ma funkcję, która jest uruchamiana, za każdym razem, gdy użytkownicy naciskają przycisk na klawiaturze i zestaw funkcji, które kontrolują twoje zachowanie w grze. Za pomocą wywołań zwrotnych można (ponownie)decydować w czasie wykonywania, które działania zostaną podjęte.

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;
    }
};

Tutaj funkcja key_pressed używa wywołań zwrotnych przechowywanych w actions, aby uzyskać pożądane zachowanie po naciśnięciu określonego klawisza. Jeśli gracz wybiera opcję zmiany przycisku do skoków, silnik może wywołać

game_core_instance.update_keybind(newly_selected_key, &player_jump);

I tym samym zmienić zachowanie wywołania na key_pressed (które wywołania player_jump) po naciśnięciu tego przycisku następnym razem w grze.

Czym są wywołania w C++(11)?

Funkcjonalność wywołania zwrotnego może być realizowana na kilka sposobów w C++(11), ponieważ okazuje się, że kilka różnych rzeczy callable*:

• Wskaźniki funkcji (w tym wskaźniki do funkcji Członkowskich)
• std::function obiekty
• wyrażenia Lambda
• wyrażenia Bind
• Obiekty funkcyjne (klasy z przeciążonym operatorem wywołania funkcji operator())

_{* Uwaga: wskaźnik do członków danych również można wywołać, ale żadna funkcja nie jest wywoływana.}

Kilka ważnych sposobów zapisu wywołań zwrotnych w detal

• X. 1 "zapisanie" wywołania zwrotnego w tym poście oznacza składnię do zadeklarowania i nazwania typu wywołania zwrotnego.
• X. 2 "wywołanie" wywołania zwrotnego odnosi się do składni wywoływania tych obiektów.
• X. 3 "Używanie" wywołania zwrotnego oznacza składnię podczas przekazywania argumentów do funkcji za pomocą wywołania zwrotnego.

Uwaga: począwszy od C++17, wywołanie podobne do f(...) może być napisane jako std::invoke(f, ...), które również obsługuje wskaźnik do sprawy członka.

1. Funkcja wskaźniki

Wskaźnik funkcji jest 'najprostszym' (pod względem ogólności; pod względem czytelności prawdopodobnie najgorszym) typu callback może mieć.

Niech będzie prosta funkcja foo:

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

1.1 zapis wskaźnika funkcji / notacji typu

A typ wskaźnika funkcji ma zapis

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

Gdzie nazwany wskaźnik funkcji będzie wyglądał tak

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;

Deklaracja using daje nam możliwość dokonania rzeczy nieco bardziej czytelne, ponieważ typedef dla f_int_t można również zapisać jako:

using f_int_t = int(*)(int);

Gdzie (przynajmniej dla mnie) jest jaśniejsze, że f_int_t jest nowym aliasem typu i rozpoznawanie typu wskaźnika funkcji jest również łatwiejsze

I deklaracja funkcji wykorzystującej wywołanie zwrotne typu wskaźnika funkcji będzie brzmiała:

// 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 zapis wywołania zwrotnego

Notacja wywołania jest zgodna ze składnią wywołania prostej funkcji:

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 Użycie notacji zwrotnej i kompatybilne typy

Funkcja zwrotna przyjmująca wskaźnik funkcji może być wywołana za pomocą wskaźników funkcji.

Użycie funkcji, która pobiera wywołanie zwrotne wskaźnika funkcji jest dość proste:

 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 przykład

Funkcja ca być napisane, że nie zależy od tego, jak callback działa:

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

Gdzie możliwe wywołania mogą być

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

Używane jak

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. Wskaźnik do członka function

Wskaźnik do funkcji członka (pewnej klasy C) jest specjalnym typem (i jeszcze bardziej złożonym) wskaźnika funkcji, który wymaga obiektu typu C do działania.

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

2.1 zapis wskaźnika do funkcji member / zapisu typu

A wskaźnik do typu funkcji member dla pewnej klasy T ma zapis

// 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)

Gdzie nazwany wskaźnik do funkcji member będzie - analogicznie do wskaźnika funkcji-wyglądał następująco to:

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;

Przykład: deklaracja funkcji przyjmującej wskaźnik do funkcji member callback jako jeden z jej argumentów:

// 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 zapis wywołania zwrotnego

Funkcja wskaźnik do członka C może być wywołana w odniesieniu do obiektu typu C poprzez użycie operacji dostępu do członka na dereferenced pointer. Uwaga: wymagany nawias!

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
}

Uwaga: Jeśli dostępny jest wskaźnik do C, składnia jest równoważna (gdzie wskaźnik do C musi być również dereferowany):

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 notacja użycia wywołania zwrotnego i typy kompatybilne

Funkcja zwrotna przyjmująca wskaźnik funkcji członka klasy T może być wywołana za pomocą wskaźnika funkcji członka klasy T.

Używanie funkcji, która pobiera wskaźnik do funkcji member callback jest-analogicznie do wskaźników funkcji-całkiem proste:

 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 (header <functional>)

The std::function class jest polimorficznym opakowaniem funkcji do przechowywania, kopiowania lub wywoływania wywołań.

3.1 zapis a std::function zapis obiektu / typu

Typ obiektu a std::function przechowującego wywołanie wygląda następująco:

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 zapis wywołania zwrotnego

Klasa std::function ma zdefiniowaną operator(), która może być użyta do wywołania jej celu.

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 notacja użycia wywołania zwrotnego i typy kompatybilne

Wywołanie zwrotne std::function jest bardziej ogólne niż Wskaźniki funkcji lub wskaźnik do funkcji member, ponieważ różne typy mogą być przekazywane i domyślnie przekształcane w obiekt std::function.

3.3.1 Wskaźniki funkcji i wskaźniki do funkcji Członkowskich

Wskaźnik funkcji

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

Lub wskaźnik do funkcji member

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

Może być używany.

3.3.2 wyrażenia Lambda

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 wyrażenia

Wynik wyrażenia std::bind może zostać przekazany. Na przykład przez powiązanie parametrów z wywołaniem wskaźnika funkcji:

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 )

Gdzie również obiekty mogą być powiązane jako obiekt wywołania wskaźnika do funkcji Członkowskich:

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 Obiekty funkcyjne

Obiekty klas posiadające odpowiednie przeciążenie operator() mogą być również przechowywane wewnątrz obiektu 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 przykład

Zmiana przykład użycia wskaźnika funkcji 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]);
  }
}

Daje o wiele więcej użyteczności tej funkcji, ponieważ (patrz 3.3) mamy więcej możliwości jej użycia:

// 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. Templated callback type

Używając szablonów, kod wywołujący callback może być jeszcze bardziej ogólny niż przy użyciu obiektów std::function.

zauważ, że szablony są funkcją czasu kompilacji i są narzędziem do projektowania polimorfizmu w czasie kompilacji. Jeśli ma zostać osiągnięte dynamiczne zachowanie środowiska uruchomieniowego poprzez wywołania zwrotne, szablony pomogą, ale nie będą wywoływać dynamiki uruchomieniowej.

Uogólnienie tzn. kodu std_ftransform_every_int z góry jeszcze bardziej można osiągnąć za pomocą szablonów:

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]);
  }
}

Uwaga: dołączone wyjście wyświetla nazwę typu wydedukowaną dla template type F. Implementacja type_name jest podana na końcu tego posta.

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 przykłady wykorzystujące szablony wywołań zwrotnych i kompatybilne typy

Typy kompatybilne dla szablonowej metody wywołania zwrotnego std::function stdf_transform_every_int_templ są identyczne z wyżej wymienionymi typami (patrz 3.4).

Korzystanie z wersji szablonowej jednak sygnatura użytego wywołania zwrotnego może się nieco zmienić:

// 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);

Uwaga: std_ftransform_every_int (wersja bez szablonów; patrz powyżej) działa z foo, ale nie używa 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";
}

Zwykły parametr szablonu transform_every_int_templ może być każdym możliwym typem wywoływalnym.

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);

Powyższy kod drukuje:

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 implementacja użyta powyżej

#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;
}