callback function

Angol

Főnév

callback function (tsz. callback functions)

(informatika) A programozásban az egyik leghasznosabb technika a callback (visszahívási) függvények használata. Ezek olyan függvények, amelyeket paraméterként adunk át más függvényeknek, és amelyek később, valamilyen esemény vagy feltétel teljesülése esetén lesznek meghívva.

A callback függvények alkalmazása segíti a rugalmas, általánosítható, moduláris programkód írását. Ezen kívül lehetővé teszik az aszinkron műveletek kezelését is (például eseményvezérelt programozásnál, GUI rendszereknél, hálózati kommunikációnál).

Alapötlet

Egy callback nem más, mint egy függvény, amit egy másik függvény paraméterként kap meg.
A hívó függvény a megfelelő időpontban „visszahívja” ezt a függvényt (innen ered az elnevezés).
Így a függvény működése testreszabható anélkül, hogy módosítani kellene a függvény eredeti kódját.

Példa motivációra

Képzeld el, hogy egy általános sorbarendező függvényt akarsz írni, ami a sorba rendezéshez nem tudhatja előre, hogy milyen szabály alapján hasonlítsa össze az elemeket (növekvő, csökkenő, valamilyen speciális sorrend).

Megoldás: az összehasonlító függvényt paraméterként adod át — callbackként.

Callback függvény típusai

Szimbolikus névként átadott függvény (function pointer, function reference)
Lambda kifejezés (C++11-től elérhető, névtelen függvény)
Functor (function object) — olyan objektum, ami a () operátort túlterheli, így úgy viselkedik, mint egy függvény.

Callback működése egyszerű példán (C++)

#include <iostream>
using namespace std;

// Egyszerű függvény, ami callbackként használható
void greet() {
    cout << "Hello from callback!" << endl;
}

// Függvény, ami paraméterként kap egy másik függvényt
void process(void (*callbackFunction)()) {
    cout << "Processing..." << endl;
    callbackFunction(); // a callback meghívása
}

int main() {
    process(greet); // átadjuk a greet függvényt callbackként
    return 0;
}

Kimenet:

Processing...
Hello from callback!

Miért hasznosak a callbackek?

Kód újrahasznosítás A függvény általános maradhat, a működést a callback szabja testre.
Eseménykezelés Például grafikus alkalmazásokban (GUI), gombnyomásra vagy más eseményre meghívható egy callback.
Aszinkron programozás Pl. hálózati kérés végeztével callback segítségével jelezhető, hogy az eredmény elkészült.
Könnyebb tesztelhetőség A callback leválasztja a műveletet a konkrét implementációtól.

Összehasonlítás lambda-val

Modern C++-ban callbackként nagyon gyakran lambdát használunk:

#include <iostream>
#include <functional>

void performTask(const std::function<void()> &callback) {
    std::cout << "Doing task..." << std::endl;
    callback();
}

int main() {
    performTask([]() {
        std::cout << "Task completed (lambda callback)!" << std::endl;
    });
    return 0;
}

Eseményvezérelt programozás példája

Képzeld el, hogy van egy gomb egy GUI alkalmazásban. A gomb megnyomásakor a felhasználó által meghatározott függvény (callback) fut le.

button.onClick([]() {
    std::cout << "Button was clicked!" << std::endl;
});

Példa sortolásra callbackkel

#include <algorithm>
#include <vector>
#include <iostream>

bool descending(int a, int b) {
    return a > b;
}

int main() {
    std::vector<int> vec = {3, 1, 4, 1, 5, 9};

    std::sort(vec.begin(), vec.end(), descending); // callback a rendezési feltétel

    for (int n : vec) {
        std::cout << n << " ";
    }
    return 0;
}

C++ callback fajták technikai részletezése

1️⃣ Function pointer

Régi C++ verziókban általános.
Szintaxis nehézkes.
Csak szabad (nem tag-) függvényekre jó.

void myCallback();  // deklaráció
void (*ptrCallback)() = myCallback; // function pointer

2️⃣ std::function

C++11 óta.
Bármilyen callable objektum (függvény, lambda, funktor) kezelhető egységesen.

std::function<void()> callback;
callback = []() { std::cout << "Lambda callback" << std::endl; };
callback();

3️⃣ Funktor (function object)

Egy osztály, ami operator()-t definiál.
Állapotot is tud tárolni (ellentétben a sima függvénnyel).

struct MyFunctor {
    void operator()() {
        std::cout << "Functor callback!" << std::endl;
    }
};

MyFunctor f;
f();

Callback tipikus felhasználási területek

1️⃣ Rendező algoritmusok

std::sort, qsort — az összehasonlító függvény callback.

2️⃣ Eseménykezelés (event-driven programming)

GUI rendszerek (Qt, GTK, WinAPI, stb.)
Egérkattintásra callback.

3️⃣ Hálózati programozás

Egy HTTP kérés befejeztével callback jelzi a választ.

4️⃣ Timer-ek

Időzített eseményeknél callbacket adunk meg, ami az idő lejárta után fut le.

5️⃣ Aszinkron I/O

Pl. fájl betöltése háttérszálon, amikor kész, callback fut.

Előnyök és hátrányok

✅ Előnyök

Rugalmas kód
Újrahasznosítható komponensek
Könnyű bővíthetőség
Alkalmas aszinkron eseménykezelésre

❌ Hátrányok

Nehezebb követni a programfolyamatot
A callback függvények „szórt” kódszerkezetet eredményezhetnek
Hibakeresés bonyolultabb lehet
Potenciális memóriaszivárgás (pl. ha nem megfelelően kezeljük az életciklust)

C++-ban modern best practice

C++11 óta std::function és lambda a legjobb kombináció callbackre.
Ez egységesíti a callable objektumokat, könnyen olvasható és biztonságos.

std::function<void(int)> onComplete;

onComplete = [](int result) {
    std::cout << "Result is: " << result << std::endl;
};

Összegzés

A callback függvény egy alapvető, mégis rendkívül erős programozási eszköz, amely lehetővé teszi a:

kód modularizálását,
testreszabható viselkedést,
eseményvezérelt, aszinkron működést.

További információk

callback function - Szótár.net (en-hu)
callback function - Sztaki (en-hu)
callback function - Merriam–Webster
callback function - Cambridge
callback function - WordNet
callback function - Яндекс (en-ru)
callback function - Google (en-hu)
callback function - Wikidata
callback function - Wikipédia (angol)