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
static
kulcsszó 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.