C++ Szerkezet a példával

Például:

Tegyük fel, hogy információkat kell tárolnia valakiről, a 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 a név, állampolgárság és életkor.

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

Mikor használjunk szerkezetet?

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

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

C++ Struktúra inicializálása

A C++ struktúra esetén a struct kulcsszót használjuk, amelyet egy azonosító követ. Az azonosító lesz a struktúra neve. Itt van az a létrehozásának szintaxisa C++ struktúra:

Syntax:

struct struct_name  
{  
     // struct members
}   

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

A szerkezeti elemek a kapcsos zárójelek között vannak hozzáadva. 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 Személy egy háromtagú szerkezet. A tagok között szerepel név, állampolgárság és életkor. Az egyik tag char adattípusú, míg a maradék 2 egész szám, amikor egy struktúra létrejön, a memória nincs lefoglalva. A memória csak akkor kerül lefoglalásra, ha egy változót hozzáadtunk a struktúrához.

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

A fenti példában létrehoztunk egy Személy nevű struktúrát. A következőképpen hozhatunk létre struktúraváltozót:

Person p;

A p egy Személy típusú struktúraváltozó. Ezzel a változóval elérhetjük a struktúra tagjait.

Struktúratagok elérése

A struktúratagok eléréséhez a struct példányát és a pont (.) operátort használjuk. Például a struct Person tag életkorának eléréséhez:

p.age = 27;

A struct Person tag korát a struct példányával fértünk hozzá, p. Ezután a tag életkorának értékét 27 évre állítottuk.

Példa 1:

#include <iostream>    
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;
}

output:

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

Kód magyarázata:

1. Szerelje be a programunkba az iostream fejlécfájlt a benne meghatározott funkciók használatához.
2. Szerelje be az std névteret az osztályok használatához anélkül, hogy meghívná.
3. Hozzon létre egy Személy nevű struktúrát.
4. A struktúratest kezdete.
5. Hozzon létre egy egész típusú állampolgárság nevű struktúratagot.
6. Hozzon létre egy age of integer nevű struktúratagot.
7. A szerkezettest vége.
8. Hívja meg a main() függvényt. A program logikáját hozzá kell adni a függvény törzséhez.
9. Hozzon létre egy példányt a Person struktúrából, és adja meg a p nevet.
10. Állítsa a struct tag állampolgárság értékét 1-re.
11. Állítsa be a struct tag age értékét 27-re.
12. Nyomtassa ki a struct tag állampolgárság értékét a konzolon más szöveg mellé.
13. Nyomtassa ki a struct tag age értékét a konzolon más szöveg mellé.
14. A programnak értéket kell visszaadnia, ha sikeresen fut.
15. A main() függvény vége.

Mutatók a szerkezetre

Létrehozhat egy mutatót, amely egy szerkezetre mutat. Hasonló a natív adattípusokra mutató mutatók létrehozásához, mint például az int, float, double stb. Ne feledje, hogy egy mutató be C++ tárol egy memóriahelyet.

Példa 2:

#include <iostream>
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;
}

output:

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

Kód magyarázata:

1. Szerelje be az iostream fejlécfájlt a programunkba, hogy használni tudja a funkcióit.
2. Szerelje be az std névteret a programunkba, hogy az osztályait hívás nélkül használhassa.
3. Hozzon létre egy Length nevű struktúrát.
4. A struktúra testének kezdete Hossz.
5. Hozzon létre egy meter nevű, egész adattípusú struktúratagot.
6. Hozzon létre egy egész szám típusú centiméter nevű struktúratagot.
7. A szerkezet testének vége Hossz.
8. Hívja meg a main() függvényt.
9. A main() függvény törzsének kezdete.
10. Hozzon létre egy *ptr mutatóváltozót és egy Length típusú normál l változót.
11. Tárolja az l változó címét a mi mutató változó.
12. Jelenítsen meg egy üzenetet a konzolon, amelyben kéri a felhasználót, hogy adja meg a változó mérőszámok értékét.
13. Olvassa be a felhasználó által a billentyűzeten beírt értéket. A tagfüggvény-mérők itt a mutatóváltozó segítségével érhetők el.
14. Jelenítsen meg egy üzenetet a konzolon, amelyben megkéri a felhasználót, hogy adja meg a változó centiméterek értékét.
15. Olvassa be a felhasználó által a billentyűzeten beírt értéket. A centiméteres tagfüggvény itt a mutatóváltozó segítségével érhető el.
16. A felhasználótól beolvasott értékek megjelenítése a konzolon más szöveg mellett.
17. A programnak értéket kell visszaadnia a sikeres végrehajtás után.
18. A main() függvény törzsének vége.

Struktúra mint függvény argumentum

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

Példa 3:

#include<iostream>
using 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<<endl;
	cout << " Person age: " << p.age;
}

output:

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

Kód magyarázata:

1. Szerelje be az iostream fejlécfájlt a fájlunkba. Ezután hiba nélkül használjuk a funkcióit.
2. Szerelje be az std névteret programunkba az osztályok használatához. Nem kell meghívnunk a névteret az osztályok használatához.
3. Hozzon létre egy Személy nevű struktúrát.
4. A struct személy testének kezdete.
5. Hozzon létre egy struct Person tagot. A tag neve állampolgárság, és egész szám típusú.
6. Hozzon létre egy struct Person tagot. A tag neve kor, és egész szám típusú.
7. A személy testének vége.
8. Hozzon létre egy függvényt, amely a struct Person, p példányát veszi argumentumként.
9. Hívja a fő funkciót. A { a main() függvény törzsének kezdetét jelöli.
10. Hozzon létre egy struct Person példányt, és adja meg a p nevet.
11. Hozzáférés a struct tag állampolgárság változójához a p struktúra példányával, és hozzárendelve az 1 értéket.
12. A struct tag változó életkora eléréséhez használja a struct példányát, a p, és rendelje hozzá a 27 értéket.
13. Hívja meg a függvényt, és argumentumként adja át neki a Person, p struktúra példányát.
14. Sikeres végrehajtás esetén a függvénynek értéket kell visszaadnia.
15. A main() függvény törzsének vége.
16. Hozza létre a függvény törzsét.
17. A függvény törzsének kezdete.
18. Hozzáférhet a struct tag állampolgárság értékéhez, és kinyomtathatja a konzolon a többi szöveg mellett.
19. Hozzáférés a struct tag kor értékéhez, és kinyomtatása a konzolon a többi szöveg mellé.
20. A függvénytörzs vége.

Korlátozása a C++ struktúra

A szerkezetek korlátai a következők:

• A struct adattípus nem kezelhető beépített adattípusként.
• Operatorokra, mint a + -, és mások nem használhatók szerkezeti változók.
• A struktúrák nem támogatják az adatok elrejtését. A struktúra tagjait bármely funkció elérheti, függetlenül annak hatókörétől.
• Statikus elemek nem deklarálhatók a szerkezet testén belül.
• Konstruktorok nem hozhatók létre egy szerkezeten belül.

Összegzésként

• A struktúra olyan adatstruktúra, amely különböző típusú adatelemeket tárol.
• Míg egy tömb hasonló típusú adatelemeket tárol, a struktúra különböző típusú adatelemeket tárol.
• Struktúrát akkor kell használni, ha az adatelemek értéke várhatóan nem változik.
• A struktúra tagjai a pont (.) operátor segítségével érhetők el.
• Létre kell hoznunk a struktúra egy példányát.
• A C++ struct, a struct kulcsszót használjuk.
• A struktúrákra mutató mutatók ugyanúgy jönnek létre, mint ahogy a normál típusokra mutató mutatók jönnek létre.
• A struktúra ugyanúgy adható át argumentumként egy függvénynek, mint a közönséges függvények.