Struktúrák (struct): Egyedi Adattípusok Készítése 🏗️

Eddig olyan alapvető adattípusokkal dolgoztunk, mint az int, double, char, bool és az std::string. Ezek nagyszerűek az egyszerű adatok tárolására. De mi van, ha egy összetettebb „dologról” szeretnénk adatokat tárolni, ami több, különböző típusú információból áll?

Például, ha egy diákról szeretnénk adatokat tárolni, akkor szükségünk van a nevére (string), életkorára (int), átlagára (double) és arra, hogy aktív-e (bool). Ha ezeket külön változókban tárolnánk, nagyon nehéz lenne őket összekapcsolni és kezelni.

Itt jönnek a képbe a struktúrák (struct)! A struktúra egy olyan felhasználó által definiált adattípus, amely lehetővé teszi, hogy különböző típusú adatokat egyetlen logikai egységbe csoportosítsunk. Olyan, mintha egy saját, személyre szabott „dobozt” készítenél, amibe különböző rekeszek vannak a különböző típusú adatoknak.

Miért van szükség struktúrákra? 🤔

• Adatok logikai összekapcsolása: Együtt kezelheted azokat az adatokat, amelyek logikailag összetartoznak (pl. egy diák összes adata).
• Kód olvashatósága és szervezettsége: Sokkal áttekinthetőbbé teszi a kódot, ha az adatok csoportosítva vannak.
• Egyszerűbb adatátadás: Egyetlen struktúra változót adhatsz át függvényeknek, ahelyett, hogy sok különálló paramétert adnál át.

Struktúra Deklarálása és Tagjai: A „Tervrajz” 📝

Egy struktúra deklarálásakor lényegében egy új adattípust definiálsz. Ez még nem foglal memóriát, csak leírja, hogy milyen adatokból fog állni az új típus. A struktúra belsejében lévő változókat tagoknak vagy mezőknek nevezzük.

Szerkezete:

struct StrukturaNev {
    Tipus1 tag_nev1;
    Tipus2 tag_nev2;
    // ...tetszőleges számú tag
}; // Fontos a pontosvessző a végén!

Példa: Egy Diak struktúra

#include <string> // std::string használatához
struct Diak {
    std::string nev;
    int eletkor;
    double atlag;
    bool aktiv;
}; // Pontosvessző a struct definíció végén!

Ez a definíció mostantól lehetővé teszi, hogy Diak típusú változókat hozzunk létre, amelyek mind a négy fenti adatot tartalmazzák.

Struktúra Változók Létrehozása és Tagjainak Elérése: A . Operátor 📦

Miután deklaráltad a struktúrát, létrehozhatsz belőle változókat (más néven példányokat). Ezek a változók foglalnak majd memóriát, és bennük tárolhatod az adatokat. A tagok eléréséhez a pont operátort (.) használjuk.

#include <iostream>
#include <string>
// Diak struktúra definíciója (általában a main előtt)
struct Diak {
    std::string nev;
    int eletkor;
    double atlag;
    bool aktiv;
};
int main() {
    // Egy 'diak1' nevű Diak típusú változó létrehozása
    Diak diak1;
    // A tagok értékének beállítása a pont operátorral
    diak1.nev = "Kiss Anna";
    diak1.eletkor = 20;
    diak1.atlag = 4.75;
    diak1.aktiv = true;
    // A tagok értékének kiíratása
    std::cout << "Diak neve: " << diak1.nev << std::endl;
    std::cout << "Eletkor: " << diak1.eletkor << std::endl;
    std::cout << "Atlag: " << diak1.atlag << std::endl;
    std::cout << "Aktiv: " << (diak1.aktiv ? "Igen" : "Nem") << std::endl;
     // Ternáris operátor a bool kiírásához
     // Létrehozhatunk és inicializálhatunk egy másik diákot is
    Diak diak2 = {"Nagy Bela", 22, 3.9, false}; 
    // Inicializálás listával (C++11 óta)
    std::cout << "\nDiak 2 neve: " << diak2.nev << std::endl;
    return 0;
}

Struktúra Tömbök: Több Összetett Elem Tárolása 📚

Ahogy az alapvető típusokból (pl. int) létrehozhatunk tömböket, úgy a struktúrákból is készíthetünk tömböket! Ez rendkívül hasznos, ha sok hasonló, összetett adatot kell tárolnunk (pl. egy osztály összes diákja).

#include <iostream>
#include <string>
struct Diak {
    std::string nev;
    int eletkor;
    double atlag;
}; // Egyszerűsített Diak struktúra
int main() {
    const int MAX_DIAK = 3;
    Diak diakok[MAX_DIAK]; // Egy 3 elemű Diak struktúra tömb
    // Első diák adatai
    diakok[0].nev = „Toth Gabor”;
    diakok[0].eletkor = 21;
    diakok[0].atlag = 4.2;
    // Második diák adatai
    diakok[1].nev = „Varga Eszter”;
    diakok[1].eletkor = 20;
    diakok[1].atlag = 4.9;
    // Harmadik diák adatai
    diakok[2].nev = „Kovacs Peter”;
    diakok[2].eletkor = 23;
    diakok[2].atlag = 3.5;
    // A diákok adatainak kiíratása ciklussal
    std::cout << „Diakok listaja:\n”;
    for (int i = 0; i < MAX_DIAK; ++i) {
        std::cout << ”  Nev: ” << diakok[i].nev
                  << „, Eletkor: ” << diakok[i].eletkor
                  << „, Atlag: ” << diakok[i].atlag << std::endl;
    }
    return 0;
}

Függvények Struktúrákkal: Adatátadás és Módosítás ➡️

Függvényeknek is átadhatunk struktúra típusú változókat paraméterként. Ezt többféleképpen tehetjük meg:

1. Érték szerint (by value): A struktúra egy másolata készül el, és az adódik át a függvénynek. Bármilyen módosítás a másolaton történik, az eredeti struktúra változatlan marad. Ez egyszerű, de nagyobb struktúrák esetén lassú és memóriapazarló lehet.

void kiirDiak(Diak d) { // Másolatot kap a struktúráról
    std::cout << "Nev: " << d.nev << ", Eletkor: " << d.eletkor << std::endl;
    d.eletkor++; // Ez csak a másolaton változtat
}
// ...
Diak diak_pelda = {"Teszt Elek", 18, 4.0};
kiirDiak(diak_pelda);
std::cout << diak_pelda.eletkor << std::endl; 
// Még mindig 18

1. Referencia szerint (by reference): A függvény egy referenciát kap az eredeti struktúrára. Nincs másolás, így hatékonyabb, és a függvény módosíthatja az eredeti struktúrát. Ez a leggyakoribb és ajánlott mód.

 void modositDiak(Diak& d) { // Referenciát kap az eredeti struktúrára
    d.eletkor++; // Ez módosítja az eredeti struktúrát!
    std::cout << "Modositott eletkor a fuggvenyben: " 
<< d.eletkor << std::endl;
}
// ...
Diak diak_pelda = {"Teszt Elek", 18, 4.0};
modositDiak(diak_pelda);
std::cout << "Eredeti diak eletkora a fuggveny utan: " 
<< diak_pelda.eletkor << std::endl; // Most 19

1. Mutató szerint (by pointer): A függvény egy mutatót kap a struktúrára. Ez is hatékony, és a függvény módosíthatja az eredeti struktúrát. A tagok eléréséhez ilyenkor a nyíl operátort (->) használjuk a pont operátor helyett.

void kiirDiakMutatoval(Diak* d_ptr) { // Mutatót kap a struktúrára

    // A nyíl operátor (->) használata
 a mutatók tagjainak eléréséhez
    std::cout << "Nev: " << d_ptr->nev << ", Eletkor: " 
<< d_ptr->eletkor << std::endl;
}
// ...
Diak diak_pelda = {"Teszt Elek", 18, 4.0};
kiirDiakMutatoval(&diak_pelda); 
// Átadjuk a struktúra címét

A struktúrák alapvető építőkövei a komplexebb adatszerkezeteknek és az objektumorientált programozásnak. Segítségükkel sokkal szervezettebb és értelmezhetőbb kódot írhatsz!