C++ Szerkezet a példával

Miben található a Struktúra C++?

A STRUCT egy C++ adatstruktúra, amely különböző adattípusú elemek tárolására használható. In C++, a struktúra egy felhasználó által definiált adattípus. A struktúra létrehoz egy adattípust a csoport számáraping különböző adattípusú elemek egyetlen adattípus alatt.

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.

Azonban előfordulhat, hogy a jövőben sok személyről kell információkat tárolnod. Ez azt jelenti, hogy különböző személyekhez tartozó változók jönnek létre. Például név1, állampolgárság1, életkor1 stb. Ennek elkerülése érdekében jobb, ha létrehozol egy struktúrát.

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:

Code Magyarázat:

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:

Code Magyarázat:

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:

Code Magyarázat:

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.

GYIK