program function

Angol

Főnév

program function (tsz. program functions)

(informatika) A függvények (function, procedure, method, subroutine, routine, subprogram) ) a C++ egyik alapvető építőelemei. Segítségükkel a kód modulárisabbá, átláthatóbbá és újrahasználhatóvá válik. Egy függvény egy adott műveletet végez el, amelyet később más helyeken is meghívhatunk.

1. Függvények alapjai

Egy függvény alapvetően a következő részekből áll:
- Visszatérési típus: Megadja, hogy milyen típusú értéket ad vissza a függvény.
- Függvénynév: Azonosítja a függvényt.
- Paraméterlista: Azok a bemenő értékek, amelyeket a függvény megkap (opcionális).
- Függvénytörzs: Az a kódrész, amely végrehajtásra kerül a függvényhívás során.
- Return utasítás: Ha a függvény visszatérési típusa nem void, akkor az utolsó utasítás visszaad egy értéket.

📌 Egyszerű függvény példája

#include <iostream>

// Összeadás függvény
int osszead(int a, int b) {
    return a + b;
}

int main() {
    int eredmeny = osszead(5, 7);
    std::cout << "Az összeg: " << eredmeny << std::endl;
    return 0;
}

🔹 Magyarázat:
- A osszead(int a, int b) egy függvény, amely két int típusú számot ad össze és visszatér az eredménnyel.
- A main() függvényben meghívjuk az osszead(5, 7) függvényt, és kiírjuk az eredményt.

2. Függvények deklarációja és definíciója

A függvénydeklaráció azt mondja meg a fordítónak, hogy egy adott függvény létezik, de nem tartalmazza a függvény törzsét. A függvénydefiníció viszont a teljes kódot tartalmazza.

📌 Példa deklarációra és definícióra

#include <iostream>

// Függvénydeklaráció
int osszead(int, int);

int main() {
    std::cout << "Összeg: " << osszead(10, 20) << std::endl;
    return 0;
}

// Függvénydefiníció
int osszead(int a, int b) {
    return a + b;
}

✅ Miért hasznos a deklaráció?
- A fordító előre tud a függvény létezéséről.
- A függvénydefiníció külön fájlban (.cpp) is lehet.
- Jobban szervezhetővé válik a kód.

3. Függvények paraméterei

A függvények különböző módon kaphatnak paramétereket.

a) Érték szerinti átadás (pass by value)

Az argumentumokat másolatként kapja meg a függvény, így az eredeti változók nem módosulnak.

void novel(int szam) {
    szam++;  // Csak a másolt értéket módosítja
}

int main() {
    int x = 10;
    novel(x);
    std::cout << x; // 10, mert az eredeti változó nem változik
}

b) Referencia szerinti átadás (pass by reference)

A függvény közvetlenül a változóra hivatkozik, így módosíthatja az eredeti értékét.

void novel(int &szam) {
    szam++;  // Az eredeti változó értéke is növekszik
}

int main() {
    int x = 10;
    novel(x);
    std::cout << x; // 11
}

c) Konstans referencia (const reference)

Ha egy változóra szeretnénk hivatkozni, de nem akarjuk módosítani, használjuk a const kulcsszót.

void kiir(const std::string &szoveg) {
    std::cout << szoveg << std::endl;
}

✅ Előnyei:
- Nagy objektumoknál (pl. string) elkerüli a felesleges másolást.
- Biztosítja, hogy a függvény nem módosítja az eredeti adatot.

4. Alapértelmezett paraméterek

A paraméterekhez alapértelmezett értéket is megadhatunk.

#include <iostream>

// Függvénydeklaráció alapértelmezett paraméterrel
void koszont(std::string nev = "Világ");

int main() {
    koszont();        // "Hello, Világ!"
    koszont("Anna");  // "Hello, Anna!"
    return 0;
}

// Definíció
void koszont(std::string nev) {
    std::cout << "Hello, " << nev << "!" << std::endl;
}

📌 Fontos:
- Az alapértelmezett értéket csak a deklarációban adjuk meg.

5. Változó számú paraméterek (variadic functions)

C++ lehetőséget ad tetszőleges számú paraméter kezelésére.

a) `stdarg.h` használatával (C-stílus)

#include <iostream>
#include <cstdarg>

int osszeg(int db, ...) {
    va_list args;
    va_start(args, db);
    int sum = 0;

    for (int i = 0; i < db; i++) {
        sum += va_arg(args, int);
    }

    va_end(args);
    return sum;
}

int main() {
    std::cout << osszeg(3, 1, 2, 3) << std::endl; // 6
}

b) Modern C++ variádikus sablonokkal

#include <iostream>

// Rekurzív sablonfüggvény
template <typename First, typename... Rest>
void kiir(First elso, Rest... tobbi) {
    std::cout << elso << " ";
    if constexpr (sizeof...(tobbi) > 0) kiir(tobbi...);
}

int main() {
    kiir(1, 2.5, "Hello", 'A');
    return 0;
}

✅ Előnyei:
- Típusbiztos és hatékonyabb, mint a stdarg.h.

6. Inline függvények

Ha egy függvény nagyon rövid, használhatjuk az inline kulcsszót.

inline int negyzet(int x) {
    return x * x;
}

int main() {
    std::cout << negyzet(5); // 25
}

✅ Miért jó?
- Csökkenti a függvényhívás költségét.

Összegzés

Téma	Leírás
Deklaráció & Definíció	A függvényt előre bejelenthetjük (`.h` fájlok)
Érték vs. Referencia átadás	Az érték szerinti másolatot készít, a referencia módosíthatja az eredeti változót
Alapértelmezett paraméterek	Opcionális argumentumokkal könnyítik a hívást
Variádikus függvények	`stdarg.h` (régi), sablonok (modern C++)
Inline függvények	Rövid, optimalizált függvényhívások

További információk

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