scope
Főnév
scope (tsz. scopes)
- alkalmazási terület
- hatály
- határ
- hatáskör
- hordtávolság
- kiterjedés
- képcső
- kör
- körzet
- működési lehetőség
- műveleti hatókör
- oszcilloszkóp
- radarernyő
- terület
- tér
- érvény
- érvényességi tartomány
- (informatika) hatókör
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.