initialization (tsz. initializations)
initialization) C++-ban azt jelenti, hogy egy változó, objektum vagy adattag kezdeti értéket kap a létrehozásakor. C++-ban többféle inicializálási szintaxis létezik, és mindegyiknek megvan a maga célja.
C++ többféle módot biztosít az inicializálásra: 1. Egyszerű (másolásos) inicializálás → int x = 5; 2. Közvetlen inicializálás → int x(5); 3. Lista-alapú inicializálás (uniform initialization, C++11) → int x{5}; 4. Default (alapértelmezett) inicializálás → int x; 5. Value (értékalapú) inicializálás → int x{};
Ez a klasszikus C++ inicializálási mód. Az értéket az = operátor segítségével adjuk meg.
#include <iostream>
int main() {
int szam = 10; // Másolásos inicializálás
double pi = 3.14;
std::string nev = "Péter";
std::cout << szam << ", " << pi << ", " << nev << std::endl;
return 0;
}
🔹 Hátrány: Bizonyos típusok esetében megenged implicit konverziót, ami nem mindig kívánatos.
Kerek zárójelekkel () történik az értékadás.
int szam(10);
double pi(3.14);
std::string nev("Péter");
🔹 Jellemzői: - Nem engedi az implicit konverziót olyan könnyen, mint a másolásos inicializálás. - Nem használható beépített típusok tömbjeinél (int tomb(5); ❌ hibás).
A lista-alapú inicializálás ({}) egy biztonságosabb módja az értékadásnak.
int szam{10};
double pi{3.14};
std::string nev{"Péter"};
🔹 Előnyei: ✔ Megakadályozza az implicit típuskonverziót!
✔ Támogatja a tömbök és objektumok biztonságos inicializálását.
Ha egy változót nem inicializálunk, annak értéke nem definiált (lokális változóknál).
int szam; // Nem inicializált, tartalma véletlenszerű
std::string nev; // Alapértelmezett üres string
🔹 Figyelem! A beépített típusok (int, double, stb.) nem inicializálódnak automatikusan!
Ha int x{} vagy int x = {} szintaxist használunk, akkor a változót 0-ra inicializáljuk.
int szam{}; // 0-ra inicializálva
double pi{}; // 0.0-ra inicializálva
std::string nev{}; // Üres string
🔹 Előnye: Nem hagyja az értéket inicializálatlanul, így megelőzi az undefined behaviort.
Tömbök esetében a lista-alapú inicializálás a legjobb megoldás.
int tomb1 = {1, 2, 3}; // Klasszikus
int tomb2{4, 5, 6}; // C++11: méretet kikövetkezteti
int tomb3{}; // Minden értéket 0-ra inicializál
🔹 Ha kevesebb értéket adunk meg, mint a tömb mérete, a maradék elemek nullázódnak.
C++-ban struktúrák és osztályok inicializálása is történhet a {} szintaxissal.
struct Ember {
std::string nev;
int kor;
};
int main() {
Ember e1{"Péter", 25}; // Lista-alapú inicializálás
Ember e2{}; // Minden érték alapértelmezetten 0 vagy üres string
std::cout << e1.nev << ", " << e1.kor << " éves" << std::endl;
}
🔹 Előnye: Minden adattagot automatikusan inicializál.
initializer list)C++ osztályokban az inicializáló lista hatékony módja az adattagok beállításának.
#include <iostream>
class Auto {
std::string marka;
int evjarat;
public:
// Inicializáló lista használata
Auto(std::string m, int e) : marka(m), evjarat(e) {}
void mutat() {
std::cout << "Márka: " << marka << ", Évjárat: " << evjarat << std::endl;
}
};
int main() {
Auto a1{"Toyota", 2020};
a1.mutat();
}
🔹 Miért jó az inicializáló lista? ✔ Hatékonyabb az értékadásnál (nincs felesleges másolás).
✔ Biztosítja, hogy a konstans adattagok (const int) inicializálva legyenek.
static változók inicializálásaA static változók csak egyszer inicializálódnak, az első használatkor.
void fuggveny() {
static int szamlalo = 0; // Egyszer inicializálódik, és megőrzi értékét
szamlalo++;
std::cout << "Számláló: " << szamlalo << std::endl;
}
int main() {
fuggveny();
fuggveny();
fuggveny();
}
🔹 Kimenet:
Számláló: 1 Számláló: 2 Számláló: 3
✅ Egyszerű inicializálás: int x = 5;
✅ Közvetlen inicializálás: int x(5);
✅ Lista-alapú inicializálás (modern): int x{5};
✅ Értékalapú inicializálás (biztonságos): int x{}; // 0-ra inicializál
✅ Tömbök inicializálása: int arr{1, 2, 3};
✅ Osztályok inicializálása inicializáló listával: Auto(std::string m) : marka(m) {}
✅ Statikus változók egyszeri inicializálása