static
Melléknév
static
A static kulcsszó C++-ban több különböző kontextusban használható, és mindegyik esetben más-más jelentéssel bír. A static változók és függvények viselkedése eltér a normál változóktól és függvényektől, főként hatókörük (scope) és élettartamuk miatt.
static kulcsszó használati esetei:
- Függvényen belüli statikus változók (helyi változók)
- Osztályon belüli statikus tagváltozók (class variables)
- Osztályon belüli statikus függvények (class methods)
- Globális és fájlszintű változók statikussá tétele
statickulcsszó egy fordítási egységre korlátozása (translation unit)
Most nézzük meg ezeket részletesen példákkal!
1. Függvényen belüli statikus változók
Egy static változó egy függvényen belül akkor is megőrzi az értékét, ha a függvény többször lefut.
🔹 Jellemzői: - Csak a deklarált függvényen belül érhető el (lokális hatókör). - Az értékét megőrzi a függvényhívások között. - Alapértelmezetten nullára inicializálódik, ha nem adunk neki kezdeti értéket.
Példa:
#include <iostream>
void countCalls() {
static int count = 0; // Csak egyszer inicializálódik!
count++;
std::cout << "Függvényhívások száma: " << count << std::endl;
}
int main() {
countCalls();
countCalls();
countCalls();
}
Kimenet:
Függvényhívások száma: 1 Függvényhívások száma: 2 Függvényhívások száma: 3
🔹 Magyarázat:
- A static int count nem jön létre újra minden hívásnál, hanem megőrzi az előző értékét.
2. Osztályon belüli statikus tagváltozók
Az osztályokban használt static változók minden objektum között megosztottak, azaz egyetlen példány létezik belőlük az egész program során.
🔹 Jellemzői: - Nem az objektumhoz, hanem az osztályhoz tartoznak. - Minden objektum ugyanazt a statikus változót használja. - Inicializálni kell az osztályon kívül.
Példa:
#include <iostream>
class Counter {
private:
static int count; // Statikus osztályváltozó
public:
Counter() {
count++;
}
static void showCount() {
std::cout << "Létrehozott objektumok száma: " << count << std::endl;
}
};
// Statikus változó inicializálása az osztályon kívül!
int Counter::count = 0;
int main() {
Counter obj1;
Counter obj2;
Counter obj3;
Counter::showCount(); // Kimenet: 3
}
Kimenet:
Létrehozott objektumok száma: 3
🔹 Magyarázat:
- A static int count minden objektum számára ugyanazt az értéket tartja. - Az obj1, obj2 és obj3 létrehozása során a count értéke megnő. - A showCount() függvényen keresztül a közös változó kiolvasható.
3. Osztályon belüli statikus függvények
Az osztály statikus függvényei nem tartoznak egy adott objektumhoz, ezért nem használhatják az osztály példányváltozóit.
🔹 Jellemzői: - Az osztályhoz tartozik, nem az egyes objektumokhoz. - Csak más statikus tagváltozókat és statikus függvényeket érhet el. - Nem kell példányosítani az osztályt ahhoz, hogy meghívjuk.
Példa:
#include <iostream>
class Math {
public:
static int square(int x) {
return x * x;
}
};
int main() {
std::cout << "4 négyzete: " << Math::square(4) << std::endl;
}
Kimenet:
4 négyzete: 16
🔹 Magyarázat:
- Nem kell példányt létrehozni az osztályból (Math obj; nélkül hívható). - Bármikor meghívható az osztály nevével: Math::square(4);.
4. Globális és fájlszintű static változók
Egy globális static változó csak abban a fájlban érhető el, ahol deklarálták.
🔹 Jellemzői: - Az adott fájlhoz korlátozódik (nem érhető el másik fájlból). - Fordítási egység szintű láthatóságot biztosít.
Példa (fájl1.cpp):
#include <iostream>
static int globalVar = 42; // Csak ebben a fájlban érhető el
void printVar() {
std::cout << "globalVar: " << globalVar << std::endl;
}
Ha ezt a változót megpróbálnánk elérni egy másik fájlban (fájl2.cpp), nem lenne elérhető.
5. static kulcsszó egy fordítási egységre korlátozása
A static függvények csak a saját fájlukban láthatók, így nem lehet őket más fájlból meghívni.
🔹 Jellemzői: - Hasznos, ha egy függvényt nem akarunk külső kódból meghívhatóvá tenni. - Kizárólag abban a fordítási egységben létezik, ahol deklarálták.
Példa:
static void hiddenFunction() {
std::cout << "Ez a függvény csak ebben a fájlban érhető el!" << std::endl;
}
Ha ezt a függvényt másik .cpp fájlban próbálnánk meghívni, hiba lenne.
Összegzés
A static kulcsszó fontos szerepet játszik a változók és függvények viselkedésének módosításában.
Legfontosabb tudnivalók:
✅ Függvényen belüli static változók megőrzik az értéküket a függvényhívások között.
✅ Osztályok static tagváltozói közösek minden objektum számára.
✅ Osztályok static függvényei az osztályhoz tartoznak, és nem az egyes objektumokhoz.
✅ Globális static változók csak abban a fájlban érhetők el, ahol deklarálták.
✅ static függvények fájlszintű láthatóságot biztosítanak.