szó jelentését keresi. A DICTIOUS-ban nem csak a
szó összes szótári jelentését megtalálod, hanem megismerheted az etimológiáját, a jellemzőit és azt is, hogyan kell a
szót egyes és többes számban mondani. Minden, amit a
szóról tudni kell, itt található. A
szó meghatározása segít abban, hogy pontosabban és helyesebben fogalmazz, amikor beszélsz vagy írsz. A
és más szavak definíciójának ismerete gazdagítja a szókincsedet, és több és jobb nyelvi forráshoz juttat.
Főnév
function call (tsz. function calls)
- (informatika) A függvényhívás (angolul function call vagy function invocation) a számítógépes programozás egyik legalapvetőbb művelete. Lényege, hogy egy előre definiált függvényt a program adott pontján végrehajtatunk. A függvény lehet beépített, vagy általunk (vagy más fejlesztő által) definiált.
Amikor egy függvényt meghívunk, akkor ezzel utasítjuk a számítógépet, hogy:
- lépjen be a függvény kódjába,
- hajtsa végre a benne lévő utasításokat,
- opcionálisan adjon vissza egy eredményt a hívó fél számára (return),
- majd térjen vissza a hívás helyére és folytassa a program végrehajtását.
1️⃣ A függvény fogalma
Egy függvény egy programon belüli önálló egység, amely bizonyos bemenet(ek)et (paramétereket) vár, ezek alapján műveleteket végez, majd eredményt (return value-t) ad vissza vagy mellékhatást fejt ki (például kiír a képernyőre).
Általános céljai:
- Kódujrahasználhatóság (reusability)
- Olvashatóság növelése (readability)
- Modularitás (modularity)
- Karbantarthatóság (maintainability)
Példa C++ nyelven:
int add(int a, int b) {
return a + b;
}
2️⃣ A függvényhívás általános szintaxisa
A függvényhívás általános formája:
függvénynév(argumentum1, argumentum2, ...);
A híváskor megadjuk a függvény nevét és a zárójelekben átadjuk a szükséges argumentumokat. Ekkor a következő történik:
- A vezérlés átkerül a függvény törzsébe.
- A függvényben lévő kód végrehajtódik.
- Ha van
return utasítás, visszaadja az eredményt.
- A vezérlés visszatér a hívás helyére.
Példa hívás:
int result = add(3, 4); // result = 7
3️⃣ Hívási mechanizmus lépései
- A hívó függvény (caller) megszakítja a saját végrehajtását.
- Stack frame (veremkeret) jön létre a hívott függvény (callee) számára.
- A paramétereket a verembe helyezi (stack vagy CPU regiszterek segítségével).
- A callee végrehajtódik.
- Eredmény (ha van) visszakerül a caller-hez.
- A stack frame felszabadul.
- A caller folytatja végrehajtását.
4️⃣ Stack frame és hívási kontextus
Minden függvényhívás során létrejön egy stack frame, amely tartalmazza:
- Paraméterek másolatát vagy referenciáját
- Lokális változókat
- Visszatérési címet (hogy hova térjen vissza a végén)
- (esetleg) hívási kontextus egyéb információit
A stack frame a call stack-en helyezkedik el. Ha függvények egymást hívják, a stack mélysége növekszik.
5️⃣ A függvényhívás típusai
a) Paraméterek szerint
- Érték szerinti átadás (pass by value): másolatot adunk át.
- Referencia szerinti átadás (pass by reference): eredeti változót adjuk át.
b) Visszatérési érték szerint
- Értéket visszaadó függvény (function with return value)
- Void függvény (void function), amely nem ad vissza semmit.
c) Függvény típusa szerint
- Szabad függvény (free function) — pl. C nyelvű
printf.
- Tagfüggvény (member function) — osztályokban (C++, Java, Python).
- Lambda / névtelen függvény (lambda / anonymous function).
6️⃣ Függvényhívási példák több nyelven
C++
int multiply(int x, int y) {
return x * y;
}
int main() {
int result = multiply(5, 6); // 30
}
Python
def greet(name):
print("Hello, " + name)
greet("Daniel")
JavaScript
function square(n) {
return n * n;
}
let result = square(8); // 64
7️⃣ Függvényhívás futásidejű hatása
A függvényhívás során a CPU-nak a következőket kell tennie:
- Eltárolja a jelenlegi utasítás helyét (PC - program counter).
- Előkészíti a paramétereket.
- Ugrik a függvény kódjára (jump/call instruction).
- Lefuttatja a függvényt.
- Visszaugrik a caller-hez a korábban eltárolt cím alapján.
A függvényhívások hatással vannak a stack mélységére. Nagyon mély vagy végtelen rekurzió stack overflow-t okozhat.
8️⃣ Rekurzív függvényhívás
A rekurzió speciális eset, amikor egy függvény saját magát hívja.
Példa (faktoriális):
int factorial(int n) {
if (n == 0) return 1;
return n * factorial(n - 1);
}
Minden egyes rekurzív híváskor új stack frame keletkezik!
9️⃣ Függvényhívási konvenciók
Különböző processzorarchitektúrákon eltérő hívási konvenciók vannak, amelyek szabályozzák:
- Hogy melyik CPU regiszterben vagy stack-en adjuk át a paramétereket.
- Ki felel a stack tisztításáért (caller vagy callee).
- Hol tároljuk a visszatérési értéket.
Példák:
- cdecl (C deklarációs konvenció)
- stdcall (Windows API)
- fastcall (paraméterek CPU regisztereken keresztül)
1️⃣0️⃣ Függvényhívás optimalizációja
A modern fordítók számos optimalizációt végezhetnek a hívásokra:
- Inline függvények: a hívás helyére a függvény kódját illesztik be.
- Tail call optimization (TCO): ha egy függvény azonnal saját magát vagy másik függvényt hív visszatérésként, a stack frame újrafelhasználható.
1️⃣1️⃣ Összefoglaló
A függvényhívás:
✅ a programvezérlés egyik alapművelete, ✅ lehetővé teszi kód újrafelhasználását, ✅ paraméterek átadásával és visszatérési értékkel működik, ✅ stack frame-eket hoz létre, ✅ CPU szinten call és ret utasításokkal valósul meg, ✅ rekurzió és inline optimalizáció esetén külön figyelmet igényel.