static binding

Angol

Főnév

static binding (tsz. static bindings)

(informatika) A statikus névkötés (static binding) vagy korai névkötés (early binding) azt jelenti, hogy egy változóhoz, függvényhez vagy más azonosítóhoz való kapcsolat már fordítási időben (compile-time) rögzül. Ez azt jelenti, hogy a fordító már a kód lefordításakor tudja, hogy egy adott azonosító melyik memóriahelyre vagy függvényre vonatkozik.

C++ nyelvben alapértelmezés szerint minden névkötés statikus, kivéve ha virtuális függvényeket használunk (dinamikus névkötés).

1. Statikus névkötés működése C++-ban

A statikus névkötés azt jelenti, hogy a függvény- vagy változóhivatkozások fordításkor kerülnek meghatározásra, és nem módosulnak futásidőben.

Példa statikus névkötésre:

#include <iostream>
using namespace std;

class Alaposztaly {
public:
    void print() { // Nem virtuális függvény -> statikus névkötés
        cout << "Alaposztaly print()" << endl;
    }
};

class Leszarmazott : public Alaposztaly {
public:
    void print() { // Nem virtuális -> statikus névkötés
        cout << "Leszarmazott print()" << endl;
    }
};

int main() {
    Alaposztaly* obj = new Leszarmazott();
    obj->print(); // Mivel print() nem virtuális, Alaposztaly print() hívódik meg
    delete obj;
    return 0;
}

Kimenet:

Alaposztaly print()

Mi történik itt?

Az obj egy Alaposztaly mutató (Alaposztaly*), amely egy Leszarmazott objektumra mutat.
Mivel a print() nem virtuális, a függvényhívás fordítási időben az Alaposztaly osztály print() függvényéhez kötődik.
Akkor is az alaposztály verziója hívódik meg, ha a mutató egy leszármazott objektumra mutat.
Ha dinamikus névkötést akarunk, a függvényt virtuálisnak kell megjelölni.

✅ A függvényhívás már a fordítás során eldől, nincs futás közbeni ellenőrzés.

2. Statikus névkötés változóknál

A legtöbb változó C++-ban statikus névkötést használ, ami azt jelenti, hogy a fordító egyértelműen hozzárendeli a változót egy adott memóriacímhez.

int main() {
    int x = 10; // 'x' a fordítási időben egyértelműen kötődik egy memóriacímhez
    cout << x << endl;
    return 0;
}

✅ A x változó már a fordításkor egyértelműen meghatározott memóriaterületre van kötve.

3. Statikus névkötés függvényeknél

A normál függvényhívások C++-ban statikus névkötést használnak, kivéve ha a függvény virtuális.

#include <iostream>
using namespace std;

void hello() {
    cout << "Hello, statikus névkötés!" << endl;
}

int main() {
    hello(); // A fordító tudja, hogy a hello() függvény melyik kódra hivatkozik
    return 0;
}

✅ Fordítási időben eldől, hogy a hello() függvény a megfelelő kódrészletet jelenti.

4. Statikus névkötés és függvény túlterhelés (Function Overloading)

A C++ támogatja a függvény túlterhelést (function overloading), ami szintén statikus névkötést használ.

Példa:

#include <iostream>
using namespace std;

void print(int x) {
    cout << "Egész szám: " << x << endl;
}

void print(double x) {
    cout << "Lebegőpontos szám: " << x << endl;
}

int main() {
    print(10);   // print(int) hívódik meg (statikus névkötés)
    print(3.14); // print(double) hívódik meg (statikus névkötés)
    return 0;
}

✅ A fordító már fordítási időben eldönti, hogy a megfelelő függvény melyik verziója hívódik meg.

5. Statikus névkötés vs. Dinamikus névkötés

Típus	Időpont	Használat	Példa
Statikus névkötés (Static Binding)	Fordítási időben	Normál függvények, statikus változók, túlterhelt függvények	Normál osztályfüggvények, függvény túlterhelés
Dinamikus névkötés (Dynamic Binding)	Futási időben	Virtuális függvények, polimorfizmus	Virtuális függvények (`virtual`)

📌 Megjegyzés:
🔹 Alapértelmezés szerint a C++ statikus névkötést használ.
🔹 Ha dinamikus névkötést akarunk, a függvényt virtual kulcsszóval kell ellátni.

6. Statikus névkötés vs. Dinamikus névkötés példával

Statikus névkötés (alapértelmezett)

#include <iostream>
using namespace std;

class Alaposztaly {
public:
    void print() { // Nem virtuális -> statikus névkötés
        cout << "Alaposztaly print()" << endl;
    }
};

class Leszarmazott : public Alaposztaly {
public:
    void print() { // Nem virtuális -> statikus névkötés
        cout << "Leszarmazott print()" << endl;
    }
};

int main() {
    Alaposztaly* obj = new Leszarmazott();
    obj->print(); // Mivel print() nem virtuális, Alaposztaly print() hívódik meg
    delete obj;
    return 0;
}

Kimenet:

Alaposztaly print()

✅ Statikus névkötés miatt mindig az Alaposztaly verziója hívódik meg.

Dinamikus névkötés (`virtual` használatával)

Ha a függvény virtuális (virtual), akkor futásidőben dől el, hogy melyik metódus hívódik meg.

#include <iostream>
using namespace std;

class Alaposztaly {
public:
    virtual void print() { // Virtuális függvény -> dinamikus névkötés
        cout << "Alaposztaly print()" << endl;
    }
};

class Leszarmazott : public Alaposztaly {
public:
    void print() override { // Dinamikus névkötés
        cout << "Leszarmazott print()" << endl;
    }
};

int main() {
    Alaposztaly* obj = new Leszarmazott();
    obj->print(); // Mivel print() virtuális, a leszármazott verziója hívódik meg
    delete obj;
    return 0;
}