C ++ struktúra példával

Tartalomjegyzék:

Anonim

Mi a Struktúra a C ++ -ban?

A STRUCT egy C ++ adatstruktúra, amely különböző adattípusok elemeinek együttes tárolására használható. A C ++ nyelven a szerkezet egy felhasználó által definiált adattípus. A struktúra adattípust hoz létre a különböző adattípusok elemeinek egyetlen adattípus alá történő csoportosításához.

Például:

Tegyük fel, hogy információkat kell tárolnia valakiről, nevéről, állampolgárságáról és életkoráról. Az adatok külön tárolásához létrehozhat olyan változókat, mint név, állampolgárság és életkor.

Előfordulhat azonban, hogy a jövőben sok személyről kell információkat tárolnia. Ez azt jelenti, hogy változók jönnek létre a különböző egyének számára. Például név1, állampolgárság1, életkor1 stb. Ennek elkerülése érdekében jobb, ha létrehozunk egy struktúrát.

Ebben a C ++ oktatóanyagban megtudhatja:

  • Mi a Struktúra a C ++ -ban?
  • Mikor kell használni a struktúrát?
  • C ++ Struktúra inicializálása
  • Struktúrapéldányok létrehozása
  • Hozzáférés a strukturális tagokhoz
  • Mutatók a szerkezetre
  • Struktúra mint függvény argumentum
  • A C ++ szerkezet korlátozása

Mikor kell használni a struktúrát?

Íme néhány ok a struktúra használatára a C ++ nyelven.

  • Használjon struktúrát, ha különböző adattípusok elemeit kell tárolnia egy adattípus alatt.
  • A C ++ struktúrák inkább értéktípusok, mint referencia típusok. Használjon struktúrát, ha nem kívánja módosítani az adatait a létrehozás után.

C ++ Struktúra inicializálása

A C ++ struktúra létrehozásához a struct kulcsszót, majd egy azonosítót használunk. Az azonosító lesz a struktúra neve. Itt található a C ++ struktúra létrehozásának szintaxisa:

Szintaxis:

struct struct_name{// struct members}

A fenti szintaxisban a struct kulcsszót használtuk. A struct_name a struktúra neve.

A strukturált tagok göndör zárójelben vannak feltüntetve. Ezek a tagok valószínűleg különböző adattípusokhoz tartoznak.

Például:

struct Person{char name[30];int citizenship;int age;}

A fenti példában a Person három tagú struktúra. A tagok között szerepel a név, az állampolgárság és az életkor. Az egyik tag char típusú, míg a fennmaradó 2 egész szám, ha egy struktúra létrejön, a memória nincs lefoglalva. A memória csak akkor kerül kiosztásra, ha egy változó hozzáadódik a struktúrához.

Struktúrapéldányok létrehozása

A fenti példában létrehoztunk egy Person nevű struktúrát. A struktúra változót a következőképpen hozhatjuk létre:

Person p;

A p egy Person típusú strukturális változó. Használhatjuk ezt a változót a struktúra tagjainak eléréséhez.

Hozzáférés a strukturális tagokhoz

A struct tagok eléréséhez a struct példányát és a dot (.) Operátort használjuk. Például, hogy elérje a struct Person tagkori életkorát:

p.age = 27;

A struct Személy tagkorához a struktúra példánya alapján jutottunk el, p. Ezután a tagkori életkor értékét 27-re állítottuk.

1. példa:

#include using namespace std;struct Person{int citizenship;int age;};int main(void) {struct Person p;p.citizenship = 1;p.age = 27;cout << "Person citizenship: " << p.citizenship << endl;cout << "Person age: " << p.age << endl;return 0;}

Kimenet:

Itt van egy képernyőkép a kódról:

Kód Magyarázat:

  1. A programban szerepeltesse az iostream fejlécfájlt az abban meghatározott funkciók használatához.
  2. Tartsa be az std névteret, hogy az osztályait hívás nélkül használhassa.
  3. Hozzon létre egy Person nevű struktúrát.
  4. A strukturált test kezdete.
  5. Hozzon létre egy egész tagú állampolgárság nevű struktúrát.
  6. Hozzon létre egy struktúra tagot, amelynek neve: type of type egész.
  7. A strukturált test vége.
  8. Hívja meg a main () függvényt. A program logikát hozzá kell adni ennek a függvénynek a törzséhez.
  9. Hozzon létre egy példányt a struct Person-ből, és adja meg neki a p nevet.
  10. Állítsa a strukturált tag állampolgárság értékét 1-re.
  11. Állítsa a struct tag életkorát 27-re.
  12. Nyomtassa ki a konzolon a strukturált tag állampolgárság értékét más szöveg mellett.
  13. Nyomtassa ki a konzolon a strukturált tag korának értékét más szöveg mellé.
  14. A programnak vissza kell adnia egy értéket, ha sikeresen fut.
  15. A fő () függvény vége.

Mutatók a szerkezetre

Lehetőség van mutató létrehozására, amely egy szerkezetre mutat. Hasonló ahhoz, ahogyan a natív adattípusokra mutató mutatók, például int, float, double, stb. Ne feledje, hogy a C ++ nyelvű mutató egy memóriahelyet tárol.

2. példa:

#include using namespace std;struct Length{int meters;float centimeters;};int main(){Length *ptr, l;ptr = &l;cout << "Enter meters: ";cin >> (*ptr).meters;cout << "Enter centimeters: ";cin >> (*ptr).centimeters;cout << "Length = " << (*ptr).meters << " meters " << (*ptr).centimeters << " centimeters";return 0;}

Kimenet:

Itt van egy képernyőkép a kódról:

Kód Magyarázat:

  1. Tartsa be az iostream fejléc fájlt programunkba annak funkcióinak használata érdekében.
  2. Vegye fel az std névteret programunkba, hogy az osztályait hívás nélkül használhassa.
  3. Hozzon létre egy Hosszú nevű struktúrát.
  4. A struktúra hosszának kezdete.
  5. Hozzon létre egy struktúratagot, az egész adattípus métereként.
  6. Hozzon létre egy egész számot tartalmazó centiméter nevű struktúrát.
  7. A struktúra hosszúságának vége.
  8. Hívja meg a main () függvényt.
  9. A fő () függvény törzsének kezdete.
  10. Hozzon létre egy mutató változót * ptr és a normál l változót, amelynek típusa: Hosszúság.
  11. Tárolja az l változó címét a mutatóváltozónkba.
  12. Jelenítsen meg egy üzenetet a konzolon, amelyben arra kéri a felhasználót, hogy adja meg a változó méterek értékét.
  13. Olvassa el a felhasználó által a billentyűzeten beírt értéket. A tagfüggvény-mérőkhöz itt lehet hozzáférni a mutatóváltozó segítségével.
  14. Jelenítsen meg egy üzenetet a konzolon, amelyben arra kéri a felhasználót, hogy adja meg a változó centiméter értékét.
  15. Olvassa el a felhasználó által a billentyűzeten beírt értéket. A centiméter tagfüggvény itt érhető el a mutató változó segítségével.
  16. Jelenítse meg a felhasználó által olvasott értékeket a konzolon más szöveg mellett.
  17. A programnak sikeres végrehajtáskor vissza kell adnia egy értéket.
  18. A fő () függvény törzsének vége.

Struktúra mint függvény argumentum

Struktúrát átadhat egy függvénynek argumentumként. Ez ugyanúgy történik, mint egy normális érv átadása. A struktúraváltozók átadhatók egy függvénynek is. Jó példa erre, amikor meg kell jelenítenie a struct tagok értékeit. Bemutassuk ezt:

3. példa:

#includeusing namespace std;struct Person{int citizenship;int age;};void func(struct Person p);int main(){struct Person p;p.citizenship = 1;p.age = 27;func(p);return 0;}void func(struct Person p){cout << " Person citizenship: " << p.citizenship<

Kimenet:




Itt van egy képernyőkép a kódról:




Kód Magyarázat:


    

  1. Helyezze be az iostream fejléc fájlt a fájlunkba. Ezután hibajavítás nélkül fogjuk használni a funkcióit.
    2. 

  2. Az osztályok használatához vegye fel programunkba az std névteret. Az osztályok használatához nem kell meghívnunk a névteret.
    3. 

  3. Hozzon létre egy Person nevű struktúrát.
    4. 

  4. A strukturált Személy testének kezdete.
    5. 

  5. Hozzon létre egy tagot a struct Person-ből. A tag neve állampolgárság, és típusa egész szám.
    6. 

  6. Hozzon létre egy tagot a struct Person-ben. A tag neve kor és egész típusú.
    7. 

  7. A strukturált személy testének vége.
    8. 

  8. Hozzon létre egy olyan függvényt, amely argumentumként a struct Person (p) példányát veszi fel.
    9. 

  9. Hívja meg a fő funkciót. A {a main () függvény törzsének kezdetét jelöli.
    10. 

  10. Hozzon létre egy példát a Struct Person-ről, és adja meg neki a nevet.
    11. 

  11. Hozzáférés a struct tag változó állampolgársághoz a struct p példa használatával és az 1 érték hozzárendelésével.
    12. 

  12. Hozzáférés a struct tag változó életkorához a pt struktúra példányának használatával és a 27 érték hozzárendelésével.
    13. 

  13. Hívja meg a függvényt, és adja hozzá argumentumként a Struct Person, p példányát.
    14. 

  14. A függvénynek sikeres végrehajtáskor vissza kell adnia egy értéket.
    15. 

  15. A fő () függvény törzsének vége.
    16. 

  16. Hozza létre a függvény törzsét.
    17. 

  17. A függvény törzsének kezdete.
    18. 

  18. Nyissa meg a strukturált tag állampolgárság értékét, és nyomtassa ki a konzolra a többi szöveg mellé.
    19. 

  19. Nyissa meg a struktúratag életkor értékét, és nyomtassa ki a konzolra a többi szöveg mellé.
    20. 

  20. A függvénytest vége.
    21. 




A C ++ szerkezet korlátozása


A struktúrák korlátai a következők:


    

  • A strukturált adattípus nem kezelhető beépített adattípusokként.
    • 

  • Az olyan operátorok, mint a + -, és mások, nem használhatók fel a struktúraváltozókra.
    • 

  • A struktúrák nem támogatják az adatok elrejtését. A struktúra tagjai bármely funkcióval hozzáférhetők, annak hatókörétől függetlenül.
    • 

  • A statikus tagok nem deklarálhatók a szerkezettesten belül.
    • 

  • A szerkezeteket nem lehet létrehozni.
    • 



Összegzés:


    

  • A struct egy olyan adatstruktúra, amely különböző típusokhoz tartozó adatelemeket tárol.
    • 

  • Míg egy tömb hasonló típusú adatelemeket tárol, addig a struct különböző típusú elemeket tárol.
    • 

  • Struktúrát kell használni, ha az adatelemek várhatóan nem változtatnak az értékén.
    • 

  • A struktúra tagjai a dot (.) Operátor segítségével érhetők el.
    • 

  • Létre kell hoznunk a struktúra példányát.
    • 

  • A C ++ struktúra létrehozásához a struct kulcsszót használjuk.
    • 

  • A struktúrára mutató mutatók ugyanúgy jönnek létre, mint a reguláris típusokra mutató mutatók.
    • 

  • A struktúra argumentumként átadható egy függvénynek ugyanúgy, mint a közönséges függvények.
    •