Ugrás a tartalomhoz

function pointer

A Wikiszótárból, a nyitott szótárból


Főnév

function pointer (tsz. function pointers)

  1. (informatika) A function pointer (függvénymutató) egy olyan mutató, amely egy függvény címét tárolja, és lehetővé teszi annak meghívását a mutatón keresztül. Ez hasznos lehet például callbackek, dinamikus függvényhívások és polimorfizmus megvalósítására.



1. Egyszerű function pointer

Egy függvénymutató típusa meg kell, hogy egyezzen a mutatott függvény típusával (visszatérési érték + paraméterek).

🔹 Példa egy egyszerű függvénymutatóra:

#include <iostream>

void sayHello() {
    std::cout << "Hello, World!\n";
}

int main() {
    void (*funcPtr)() = sayHello;  // Függvénymutató létrehozása
    funcPtr();  // Meghívás mutatón keresztül
}

💡 Fontos: A függvénymutató típusának pontosan egyeznie kell a mutatott függvény típusával.



2. Function pointer paraméterekkel

Ha a függvénynek van paramétere és visszatérési értéke, azt is figyelembe kell venni.

🔹 Példa paraméteres függvénymutatóra:

#include <iostream>

int add(int a, int b) {
    return a + b;
}

int main() {
    int (*funcPtr)(int, int) = add;  // Mutató egy függvényre, amely két int-et vesz át és int-et ad vissza
    std::cout << "Összeg: " << funcPtr(3, 4) << '\n';  // 7
}

3. Function pointer függvény paraméterként

Függvénymutatót átadhatunk egy másik függvény paramétereként is. Ez például callbackek esetén hasznos.

🔹 Példa egy függvényre, amely függvénymutatót kap:

#include <iostream>

int multiply(int a, int b) {
    return a * b;
}

void calculate(int x, int y, int (*operation)(int, int)) {
    std::cout << "Eredmény: " << operation(x, y) << '\n';
}

int main() {
    calculate(5, 6, multiply);  // 5 * 6 = 30
}

💡 A calculate() egy olyan függvényt vár paraméterként, amely két int-et fogad és egy int-et ad vissza.



4. Function pointer tömb

Tömbökben is tárolhatunk függvénymutatókat.

🔹 Példa több függvény mutatójának tárolására egy tömbben:

#include <iostream>

int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }

int main() {
    int (*operations[3])(int, int) = { add, subtract, multiply };

    std::cout << "3 + 2 = " << operations[0](3, 2) << '\n';
    std::cout << "3 - 2 = " << operations[1](3, 2) << '\n';
    std::cout << "3 * 2 = " << operations[2](3, 2) << '\n';
}

Itt egy függvénymutatók tömbjét hoztuk létre, és dinamikusan kiválaszthatjuk, melyik műveletet hajtjuk végre.



5. Function pointer osztályban (Tagfüggvény pointer)

Ha egy osztály tagfüggvényére szeretnénk mutatót létrehozni, akkor speciális szintaxisra van szükségünk.

🔹 Példa tagfüggvény mutatóra:

#include <iostream>

class MyClass {
public:
    void show() {
        std::cout << "Tagfüggvény meghívása\n";
    }
};

int main() {
    MyClass obj;
    void (MyClass::*funcPtr)() = &MyClass::show;  // Tagfüggvény pointer létrehozása
    (obj.*funcPtr)();  // Meghívás példányon keresztül
}

💡 Fontos: A tagfüggvény mutató szintaxisa eltér a normál függvénymutatótól.

🔸 Ha a pointert egy osztálypéldányra mutató pointerrel használnánk:

MyClass* objPtr = &obj;
(objPtr->*funcPtr)();

6. std::function használata (C++11)

A std::function egy modern alternatíva a függvénymutatók helyett. Előnye, hogy lambdákat, normál függvényeket és tagfüggvényeket is tud kezelni.

🔹 Példa std::function használatára:

#include <iostream>
#include <functional>

int add(int a, int b) {
    return a + b;
}

int main() {
    std::function<int(int, int)> funcPtr = add;
    std::cout << "Összeg: " << funcPtr(4, 5) << '\n';  // 9
}

💡 Az std::function biztonságosabb és rugalmasabb a nyers függvénymutatóknál.



Összegzés

Típus Példa
Egyszerű function pointer void (*ptr)() = func;
Paraméteres function pointer int (*ptr)(int, int) = add;
Függvénymutató átadása paraméterként void func(int (*ptr)(int, int));
Függvénymutató tömb int (*arr[])(int, int) = {add, sub};
Tagfüggvény pointer void (MyClass::*ptr)() = &MyClass::method;
std::function (modern) std::function<int(int, int)> f = add;