Tartalom

• Összehasonlító táblázat
• A szerkezet meghatározása
• Az Unió meghatározása
• Hasonlóságok:
• Következtetés:

A C ++ lehetővé teszi mind a C nyelv mind az öt módját, hogy egyedi adatokat hozzon létre. Ez az öt módszer: „szerkezet”, „bit-mező”, „unió”, „felsorolás”, „typedef”. Az alábbi cikkben megvizsgáljuk a szerkezet és az unió közötti különbséget. A struktúra és az unió egyaránt olyan tárolótípus-típus, amely bármilyen „típusú” adatot képes tárolni. Az egyik fő különbség, amely megkülönbözteti a struktúrát és az uniót, az, hogy a szerkezetnek külön memóriahely van minden tagja számára, míg az unió tagjai ugyanazt a memóriahelyet osztják.

Megértjük a szerkezet és az unió közötti különbséget, összehasonlító diagrammal együtt.

1. Összehasonlító táblázat
2. Meghatározás
3. Főbb különbségek
4. Hasonlóságok
5. Következtetés

Összehasonlító táblázat

Az összehasonlítás alapja	Szerkezet	Unió
Alapvető	A külön memóriahelyet a struktúra minden tagjának meghatározzák.	Az unió minden tagja ugyanazt a memóriahelyet használja.
Nyilatkozat	struct struct_name { type1 elem; type2 elem; . . } változó1, változó2, ...;	unió u_name { type1 elem; type2 elem; . . } változó1, változó2, ...;
kulcsszó	struct	unió
Méret	Szerkezet mérete = az összes adat tag méretének összege.	Unió mérete = a legnagyobb tagok mérete.
Store érték	Különböző értékeket tárol az összes tag számára.	Minden tag számára azonos értéket tárol.
Egy időben	Egy struktúra több értéket tárol a struktúra különböző tagjai közül.	A szakszervezet egyetlen értéket tárol egyszerre minden tag számára.
A megtekintés módja	Adjon meg egyetlen módot az egyes memóriahelyek megtekintésére.	Többféle módon biztosíthatja ugyanazon memóriahely megtekintését.
Névtelen szolgáltatás	Nincs névtelen szolgáltatás.	Anonim szakszervezet bejelenthető.

A szerkezet meghatározása

A struktúra a különféle adattípusok változóinak gyűjteménye, amelyeket köznévvel utalnak. A struktúrában szereplő változókat „tagoknak” nevezzük. Alapértelmezés szerint a struktúra összes tagja „nyilvános”. Amikor deklarál egy struktúrát, létrehoz egy sablont, amely felhasználható szerkezeti objektumok létrehozására, megosztva ugyanazt az adatagok és tagfunkciók szervezetet. A struktúra deklarálását mindig az „struct” kulcsszó előzi meg, amely azt mondja a fordítónak, hogy a struktúrát deklarálták. Vegyünk egy példát.

Vegyünk egy példát.

struct alkalmazott {karakterlánc neve; karakterlánc cégnév; húrváros; } Emp1, emp2;

Itt deklarálunk egy struktúrát az alkalmazottak információinak tárolására. A deklaráció pontosvesszővel fejeződik be, mivel a struktúra deklaráció egy utasítás, és a C ++ esetében az utasítás pontosvesszővel fejeződik be.

A struktúrának adott név egy „típust” határoz meg (a fenti példában a struktúra neve „alkalmazott”). Az ilyen típusú változók létrehozhatók, mint fentebb, két „emp1” és „emp2” típusú „alkalmazott” típusú változót hoztunk létre. A fenti példában egy „szerkezeti” változót hoztunk létre közvetlenül a deklaráció után; felváltva külön is létrehozható.

struct alkalmazott emp1, emp2; // a struct kulcsszó nem kötelező.

A szerkezeti változó tagjai inicializálhatók vagy hozzáférhetők a dot (.) Operátor használatával.

emp1.name = "Ashok";

Az egyik szerkezeti változóban található információ hozzárendelhető egy másik, ugyanolyan típusú szerkezeti változóhoz, mint a következő.

emp1.name = "Ashok"; emp1.company_name = "Teckpix"; emp1.city = "Delhi"; emp2 = emp1; // az emp1 tag értékeinek hozzárendelése az emp2-hez. cout <

Itt az 'emp1' szerkezeti változót 'emp2' -hez rendeltük, az 'emp1' a tagok összes értékét az 'epm2' megfelelő tagjára másolja.

A szerkezeti változó tagja átadható a függvénynek.

funct (emp1.city);

A teljes szerkezeti változó átadható a függvénynek, mind a módszer szerint hívás érték alapján, mind referencia szerint.

funt (emp1); // hívás funkció hívásérték módszer szerint. . . void funct (struct alkalmazott emp) {// az emp1 tagjainak értékeinek kiszámítása. cout <

Ebben az esetben a szerkezeti változó egy tagjának értékében bekövetkező változás nem tükröződik a függvényen kívül, mivel a változót hívás-érték módszerrel továbbítják. Most csináljuk ugyanazt a műveletet hívás alapján referencia módszer szerint.

funt (& emp1); // hívás funkció hívás alapján referencia módszerrel. . . void funct (struct alkalmazott * emp) {// az emp1 fogadó címe. EMP> city = "Nur"; // módosítsa az emp1 szerkezeti változó tagjának (városának) értékét. . }

Itt a szerkezeti változót referenciával adjuk át, tehát a szerkezeti változó tagjainak értékére történő változás a funkción kívül is tükröződik.

alkalmazott alkalmazott * emp; // a típusú alkalmazott szerkezeti mutatójának dekódolása. EMP = & emp1; // az emp1 cím hozzárendelése a mutatóhoz. emp-> city // az emp1 tagváros eléréséhez szükséges mutató.

A struktúrára mutató mutató is létrehozható; a szerkezeti változó címét tartja.

A struktúrában az összesített inicializálás akkor megengedett, ha a struktúradefiníció nem tartalmaz semmilyen felhasználó által definiált konstruktort vagy virtuális funkciót vagy alaposztályt, vagy privát vagy védett mezőt.

int main () {struct epm3 = {"Anil", "Teckpix", "Nur"}; } // Lehetséges, mivel a munkavállalói szerkezet nem tartalmaz a fent említett dolgokat.

Az Unió meghatározása

Az unió egy olyan memóriahely, amelyet két vagy több különféle típusú változó oszt meg, egyetlen uniótípus alatt deklarálva. A szakszervezet szakszervezésének kulcsszava: „unió”. A C ++ esetében az unió mind tagfüggvényt, mind változókat tartalmazhat. Alapértelmezés szerint az unió minden tagja „nyilvános”. Az „unió” nyilatkozata hasonló a szerkezet deklarálásához.

union u_type {int x, char c; úszó f; } u1, u2;

Itt bejelentettük az u_type nevű uniót. Az u_type tagjai egész számú „x”, karakter típusú „c” és úszó típusú „f”. Ugyancsak az unió bejelentése után létrehoztuk az „u1” és az „u2” unióváltozókat, „u_type” típusúak. A szakszervezeti változót az unió deklarációjától külön is bejelenthetjük.

int main () {u1, u2 unió; // A C ++ kulcsszó unió nem kötelező. }

Az unió tagjainak elérése dot (.) Operátor használatával történhet, amelyet az unió változó előz meg, majd a változó tagját követi.

u1.x = 10;

A struktúrákhoz hasonlóan az összesített inicializálás nem lehetséges unión belül. Mint tudjuk, hogy az unió megosztja ugyanazt a memóriahelyet az összes tagja számára, egyszerre csak egy változó inicializálódik, és az összes változó automatikusan frissül az inicializált értékkel.

u1.x = 10; cout <

Ha megpróbálja megváltoztatni az 'u1' bármelyik tagjának értékét. A másik tag automatikusan frissül erre az értékre.

u1.c = 65; cout <

Az unió számára fenntartott terület megegyezik a szakszervezet legnagyobb tagjának méretével. Mivel a „char” -nak elrendelt bájt 1 byte, az „int” 4 byte és a „float” 4 byte, tehát a legnagyobb méret 4 byte. Tehát az „u1” és az „u2” memória 4 bájtos.

int main () {int size_1 = size (u1); // 4 int méret_2 = méret (u2); // 4

Az unió mutatója ugyanúgy létrehozható, mint a szerkezete. A mutató az unió címét tartalmazza.

union u_type * un; un = & u1; cout <x; // 10

A struktúrához hasonlóan az uniót a módszerekre is átadhatjuk a módszerekkel, azaz hívás érték alapján és hívás referenciával.

funct (U1); // hívás funkció hívásérték módszer szerint. . . void funct (unió u_type un) {// megkapja az u1 tagjának értékét. cout <

Hívjuk fel a függvényt hívás referencia módszerrel.

funct (& u1); // hívás funkció hívás alapján refrence módszerrel. . . void funct (unió u_type un) {// az u1 címének lekérdezése. un-> x = 20. }

A C ++-ban létezik egy speciális típusú unió, amelyet Anonim Uniónak hívnak. Az anonim uniónak nem lehet típusneve, és nem hozható létre ilyen unió változója. Csak azt kell mondani a fordítónak, hogy tagváltozói ugyanazt a helyet osztják meg. Az anonim unió változója a normál pont (.) Operátor nélkül hivatkozható.

int main () {union {// meghatározza az anonim uniót a típusnév nélkül. int x, char c; úszó f; }; x = 10; // az unióváltozót mutatta ki a pontkezelő cout-val <

Az anonim unióban nem engedélyezett tagsági funkció, nem tartalmazhat magán- vagy védett adatokat, és a globális anonim uniót statikusként kell megadni.

A szokásos szakszervezeti nyilatkozatra emlékeztető pontok

• Az unió meghatározása tartalmazhat konstruktort és destruktort is.
• Az unió számos lehetőséget kínál ugyanazon memóriahely megtekintésére.
• Az unió semmilyen típusú osztályt nem örökölhet.
• Az unió nem lehet alaposztály.
• Az uniónak nem lehet virtuális tag funkciója.
• Az uniónak nem lehet statikus változója.

1. A szerkezet különböző memóriahelyeket használ a különböző tagok számára. Ezért a megkülönböztetett érték minden tag számára kiosztható. De az unió ugyanazt a memóriahelyet osztja meg minden tagjának. Ezért egyetlen értéket lehet kiosztani az összes tag számára.
2. A szerkezetnek minden tagja számára eltérő a memória helye; ennélfogva egyidejűleg több értéket is tartalmazhat, és mivel tudjuk, hogy az unió megosztja a memóriahelyet az összes taggal, így egyszerre egyetlen értéket tárolhat.
3. Általában a szerkezet teljes mérete nagyobb, mint az unió teljes mérete, mivel egy struktúra mérete a szerkezetek összes tagja összegének összege, és az egyesület mérete az egyes tagok méretének összege. legnagyobb típus.
4. A struktúra az egyes helyekről egyetlen képet nyújt, míg az unió egyetlen hely több nézetét nyújtja.
5. Bejelenthet névtelen uniót, de nem névtelen struktúrát.

Hasonlóságok:

• Mind a szerkezet, mind az unió azonos módon deklarálja magát, létrehozza a változókat, és ugyanúgy hozzáfér a változók tagjaihoz.
• Mind a struktúrát, mind az uniót át lehet adni egy függvénynek mind az érték szerint, mind a referencia szerint.
• Mind a szerkezet, mind az egység tároló adattípus, és bármilyen adattípus objektumot tartalmaznak, beleértve tagjaiként az egyéb struktúrákat, uniókat és tömböket.

Következtetés:

A szerkezet és az unió egyaránt a tároló adattípus, amely különféle típusú tagokat tartalmaz. De a struktúrákat akkor használják, amikor különálló értéket kell tárolni az összes tag számára, egy külön memóriahelyen. A szakszervezeteket akkor használják, amikor típuskonverzióra van szükség.