scope

Angol

Főnév

scope (tsz. scopes)

A hatókör (scope) a változók és más azonosítók (például függvények, osztályok) láthatóságát és érvényességét határozza meg egy C++ programban. Másképpen fogalmazva, a hatókör azt mondja meg, hogy egy adott változó vagy függvény mely részeken érhető el és használható.

A C++ hatókörök többféleképpen kategorizálhatók:

Lokális (helyi) hatókör
Globális hatókör
Blokkhatókör
Osztály (class) hatókör
Függvény hatókör
Névtér (namespace) hatókör
Fájlszintű hatókör
Dinamikusan allokált változók hatóköre

Most nézzük meg ezeket részletesen!

1. Lokális (helyi) hatókör

Egy lokális változó csak abban a blokkban érhető el, amelyben létrehozták.

Példa:

#include <iostream>

void myFunction() {
    int x = 10;  // Lokális változó
    std::cout << "x értéke: " << x << std::endl;
}

int main() {
    myFunction();
    // std::cout << x;  // HIBA! x nincs definiálva ebben a hatókörben.
}

🔹 Magyarázat:
- Az x változó csak a myFunction() függvényen belül érhető el, kívülről nem.

2. Globális hatókör

A globális változók a teljes programban elérhetők, ha a függvények és más kódrészek is látják őket.

Példa:

#include <iostream>

int globalVar = 100;  // Globális változó

void display() {
    std::cout << "Globalis valtozo: " << globalVar << std::endl;
}

int main() {
    std::cout << "GlobalVar: " << globalVar << std::endl;
    display();
}

🔹 Magyarázat:
- A globalVar bárhonnan elérhető a programban, mivel globális változóként lett deklarálva.

⚠ Figyelem! A globális változók túlzott használata rossz programozási szokás, mert nehezíti a kód olvashatóságát és karbantartását.

3. Blokkhatókör

Egy változó csak abban a blokkban (két {} között) érhető el, amelyben deklarálták.

Példa:

#include <iostream>

int main() {
    int a = 5;
    
    {
        int b = 10;  // b csak ebben a blokkban elérhető
        std::cout << "b: " << b << std::endl;
    }
    
    // std::cout << b;  // HIBA! b nincs elérhető itt.

    return 0;
}

🔹 Magyarázat:
- A b változó csak a belső blokkban érhető el, kívülről nem.

4. Osztály (class) hatókör

Az osztályok tagjai (változók és függvények) különböző hozzáférési módosítókkal rendelkezhetnek.

Példa:

#include <iostream>

class MyClass {
private:
    int privateVar;  // Csak az osztályon belül érhető el

public:
    int publicVar;   // Bárhonnan elérhető

    void setPrivateVar(int value) {
        privateVar = value;
    }

    int getPrivateVar() {
        return privateVar;
    }
};

int main() {
    MyClass obj;
    obj.publicVar = 10;
    obj.setPrivateVar(20);

    std::cout << "Public var: " << obj.publicVar << std::endl;
    std::cout << "Private var: " << obj.getPrivateVar() << std::endl;

    // obj.privateVar = 30;  // HIBA! private változó nem érhető el kívülről
}

🔹 Magyarázat:
- private tagok csak az osztályon belül érhetők el.
- public tagok bárhonnan elérhetők.
- Getter és setter függvényekkel lehet módosítani a private változókat.

5. Függvény hatókör

A függvényen belül deklarált változók csak az adott függvényen belül érvényesek.

Példa:

#include <iostream>

void myFunction() {
    int localVar = 42;
    std::cout << "localVar: " << localVar << std::endl;
}

int main() {
    myFunction();
    // std::cout << localVar;  // HIBA! localVar nincs definiálva itt.
}

🔹 Magyarázat:
- A localVar változó csak a myFunction() belsejében érhető el.

6. Névtér (namespace) hatókör

A névterek (namespace-ek) lehetővé teszik az azonos nevű változók és függvények elkülönítését.

Példa:

#include <iostream>

namespace first {
    int x = 5;
}

namespace second {
    int x = 10;
}

int main() {
    std::cout << "first::x = " << first::x << std::endl;
    std::cout << "second::x = " << second::x << std::endl;
}

🔹 Magyarázat:
- A különböző névterekben lévő x változók nem ütköznek egymással.

7. Fájlszintű hatókör (static)

A static kulcsszóval jelölt változók és függvények csak az adott fájlon belül érhetők el.

Példa:

static int fileScopedVar = 10; // Csak ebben a fájlban érhető el

8. Dinamikusan allokált változók hatóköre

A new operátorral létrehozott dinamikus változók nem függnek a blokkhatókörtől.

Példa:

#include <iostream>

int* createDynamicVar() {
    int* ptr = new int(50); // Dinamikus memóriafoglalás
    return ptr;
}

int main() {
    int* myPtr = createDynamicVar();
    std::cout << "Ertek: " << *myPtr << std::endl;
    delete myPtr; // Felszabadítjuk a memóriát
}

🔹 Magyarázat:
- A new operátorral létrehozott változók addig léteznek, amíg fel nem szabadítjuk őket (delete).

Összegzés

A C++ hatókörök segítenek a programok olvashatóságának és biztonságának növelésében. A legfontosabb hatókörök:

✅ Lokális: csak a blokkban elérhető.
✅ Globális: mindenhol elérhető, de óvatosan kell használni.
✅ Osztály hatókör: az adatok elrejtésére szolgál.
✅ Névtér (namespace): névütközések elkerülésére jó.
✅ Dinamikus változók: addig léteznek, amíg fel nem szabadítjuk őket.

További információk

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