Wie funktionieren Rückrufe in C und welche verschiedenen Verwendungszwecke gibt es?

Rückrufe und ihre verschiedenen Verwendungen in C

In C ist ein Rückruf ein aufrufbarer Wert (später besprochen), der von einer Klasse oder Funktion akzeptiert wird. Wird verwendet, um die aktuelle Logik basierend auf dem bereitgestellten Rückruf anzupassen.

Gründe für die Verwendung Rückrufe:

• Zum Schreiben von generischem Code unabhängig von der Logik in der aufgerufenen Funktion, der die Wiederverwendung mit verschiedenen Rückrufen ermöglicht.
• Um Aufrufer über bestimmte Ereignisse zu benachrichtigen und Statik und Kompilierung zu ermöglichen -Zeitflexibilität.

Was sind Callables in C ?

• Funktionszeiger (einschließlich Zeiger auf Mitgliedsfunktionen)
• std::function object
• Lambda-Ausdrücke
• Bindungsausdrücke
• Funktionsobjekte (Klassen mit überladenem Funktionsaufrufoperator). Operator())

Rückrufe schreiben und aufrufen:

Funktionszeiger:

• Typ-Notation: return_type (*)(parameter_type_1, parameter_type_2, parameter_type_3)
• Callback Call Notation: function_pointer(argument)
• Callback Use Notation: function(argument_list, function_pointer)

Zeiger auf Mitglied Funktion:

• Typnotation: return_type (class_type::*)(parameter_type_1, parameter_type_2, parameter_type_3)
• Callback Call Notation: (class_instance.*member_function_pointer)(argument)
• Callback Use Notation: function(argument_list, class_instance, member_function_pointer)

std::function Objekte:

• Typnotation: std::function
• Callback Call Notation : function_object()
• Callback Use Notation: function(argument_list, function_object)

Beispiele für die Verwendung von std::function:

Verallgemeinern Code:

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

Templatete Rückrufe:

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

Typnamen-Implementierung:

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 += " &amp;&";
  else if (std::is_rvalue_reference<T>::value)
    r += " &amp;&amp;";
  return r;
}

Das obige ist der detaillierte Inhalt vonWie funktionieren Rückrufe in C und welche verschiedenen Verwendungszwecke gibt es?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!