Innehåll

• Jämförelsediagram
• Definition av struktur
• Definition av unionen
• Likheter:
• Slutsats:

C ++ tillåter alla fem sätt som C-språket tillhandahåller för att skapa en anpassad data. Dessa fem sätt är 'struktur', 'bitfält', 'förening', 'uppräkning', 'typedef'. I artikeln nedan ska vi studera skillnaden mellan struktur och förening. Strukturen och sammanslutningen är båda behållardatatyperna som kan innehålla data av alla ”typer”. Den största skillnaden som skiljer struktur och förening är att strukturen har en separat minnesplats för var och en av dess medlemmar medan medlemmarna i en fackförening delar samma minnesplats.

Låt oss förstå skillnaden mellan struktur och förening, tillsammans med ett jämförelsediagram.

1. Jämförelsediagram
2. Definition
3. Viktiga skillnader
4. Likheter
5. Slutsats

Jämförelsediagram

Grund för jämförelse	Strukturera	Union
Grundläggande	Den separata minnesplatsen tilldelas varje medlem av strukturen.	Alla medlemmar i fackföreningen delar samma minnesplats.
Deklaration	struct struct_name { typelement1; typ element2; . . } variabel1, variabel2, ...;	union u_name { typelement1; typ element2; . . } variabel1, variabel2, ...;
nyckelord	struct	union
Storlek	Strukturens storlek = summan av storleken på alla datamedlemmar.	Unionens storlek = storleken på de största medlemmarna.
Lagra värde	Lagrar olika värden för alla medlemmar.	Lager samma värde för alla medlemmar.
Vid en tid	En struktur lagrar flera värden, för de olika medlemmarna, i strukturen.	En fackförening lagrar ett enda värde åt gången för alla medlemmar.
Sätt att se	Ge ett enda sätt att visa varje minnesplats.	Ge flera sätt att visa samma minnesplats.
Anonym funktion	Ingen anonym funktion.	Anonym förening kan förklaras.

Definition av struktur

Strukturen är en samling variabler av olika datatyper, som hänvisas till med ett vanligt namn. Variablerna i en struktur kallas "medlemmar". Som standard är alla medlemmar i en struktur "offentliga". När du förklarar en struktur skapar du en mall som kan användas för att skapa strukturobjekt och delar samma organisation av dataledamöter och medlemsfunktioner. Deklarationen av strukturen föregås alltid av nyckelordet "struktur", som säger kompilatorn att en struktur har deklarerats. Låt oss ta ett exempel.

Låt oss ta ett exempel.

strukt medarbetare {strängnamn; sträng företagets namn; strängstad; } Emp1, emp2;

Här förklarar vi en struktur för lagring av anställdas information. Förklaringen avslutas med ett semikolon, eftersom strukturdeklarationen är ett uttalande och i C ++ avslutas uttalandet av ett semikolon.

Namnet som ges till en struktur definierar en ”typ” (i exemplet ovan är namnet på strukturen ”anställd”). Variablerna av dessa typer kan skapas, som ovan skapade vi två variabler "emp1" och "emp2" av typen "anställd". I exemplet ovan skapade vi en "struktur" -variabel strax efter deklarationen; alternativt kan det skapas separat.

strukt medarbetare emp1, emp2; // nyckelordstrukturen är inte obligatorisk.

Medlemmarna i en strukturvariabel kan initialiseras eller kan nås med hjälp av dot (.) -Operatören.

emp1.name = "ashok";

Informationen i en strukturvariabel kan tilldelas en annan strukturvariabel av samma typ som följer.

emp1.name = "ashok"; emp1.company_name = "Teckpix"; emp1.city = "Delhi"; emp2 = emp1; // tilldela värden för medlemmen av emp1 till emp2. cout <

Här tilldelade vi strukturvariabeln 'emp1 ′ till' emp2 ′ så ', emp1 ′ kopierar alla värden på dess medlemmar till motsvarande medlem av' epm2 '.

Elementet i strukturvariabeln kan överföras till funktionen.

funkt (emp1.city);

Hela strukturvariabeln kan vidarebefordras till funktionen, både av metodernas samtal efter värde och samtal genom referens.

funt (emp1); // samtalsfunktion med samtal efter värde-metod. . . void funct (strukt anställd emp) {// receving värden för medlemmar av emp1. cout <

Här kommer inte ändringen av värdet för ett medlem i strukturvariabeln att reflektera utanför funktionen eftersom en variabel överförs med call by value-metoden. Låt oss göra samma sak genom att ringa med referensmetod.

funt (& emp1); // samtalsfunktion med samtal med referensmetod. . . void funct (strukt medarbetare * emp) {// receving address of emp1. EMP> stad = "Nur"; // ändra värdet på medlemmen (staden) på strukturvariabeln emp1. . }

Här skickas strukturvariabeln med referens så att ändring till värdet för medlemmarna i strukturvariabeln reflekterar också utanför funktionen.

srtuct anställd * emp; // dekalera strukturpekaren för anställd. emp = & emp1; // tilldela adressen till emp1 till pekaren. emp-> city // pekaren åtkomst till medlemsstaden emp1.

Pekaren till strukturen kan också skapas; det har adressen till strukturvariabel.

I struktur är den aggregerade initialiseringen tillåten när strukturdefinitionen inte innehåller någon användardefinierad konstruktör eller virtuella funktioner eller basklass eller privat eller skyddat fält.

int main () {struct epm3 = {"Anil", "Teckpix", "Nur"}; } // Möjligt eftersom anställdes struktur inte innehåller något av ovan nämnda saker.

Definition av unionen

En union är en minnesplats som delas av två eller flera olika typer av variabler som deklareras under en enda unionstyp. Nyckelordet som används för att förklara en fackförening är "fackförening". I C ++ kan en union innehålla både medlemsfunktion och variabler. Som standard är alla medlemmar i facket ”offentliga”. Förklaringen om ”fackföreningen” liknar strukturdeklarationen.

union u_type {int x, char c; flottör f; } u1, u2;

Här hade vi förklarat en fackförening som heter u_type. Medlemmarna i u_typen är 'x' av heltalstyp, 'c' av karaktärstyp och 'f' av flottörstyp. Vi hade också skapat föreningsvariablerna 'u1' och 'u2' av typen 'u_typ', precis efter förklaringen om en fackförening. Vi kan också förklara fackföreningen separat från förklaringen om en fackförening.

int main () {union u_type u1, u2; // Nyckelordet unionen är inte obligatorisk i C ++. }

Tillträde för medlemmarna i fackföreningen kan göras med hjälp av punkt (.) -Operatör, föregiven av fackföreningsvariabel och följt medlemmen i den variabeln.

u1.x = 10;

Liksom strukturer är den totala initialiseringen inte möjlig i en union. Som vi vet delar unionen samma minnesplats för alla sina medlemmar åt gången, endast en variabel initialiseras och alla variabler uppdateras automatiskt med det initialiserade värdet.

u1.x = 10; cout <

Om du försöker ändra värdet på någon medlem i 'u1'. Den andra medlemmen uppdateras automatiskt till det värdet.

u1.c = 65; cout <

Det utrymme som tilldelas facket är lika stor som den största fackmedlemmen. Eftersom byten som tilldelas "char" är 1 byte, är "int" 4 byte och "float" är 4 byte, så den största storleken är 4 byte. Så, minnet tilldelat 'u1' och 'u2' är 4 byte.

int main () {int size_1 = sizeof (u1); // 4 int size_2 = sizeof (u2); // 4

Pekaren till facket kan skapas precis som i struktur. Pekaren har unionens adress.

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

I likhet med strukturen kan föreningen också vidarebefordras till funktionerna genom både metoderna, dvs.

funkt (u1); // samtalsfunktion med samtal efter värde-metod. . . void funct (union u_type un) {// receving värdet för medlemmen i u1. cout <

Låt oss nu ringa funktionen med hjälp av samtal efter referensmetod.

funkt (& u1); // samtalsfunktion med samtal med uppfriskningsmetod. . . void funct (union u_type un) {// receving adressen till u1. un-> x = 20. }

Det finns en speciell typ av fackförening i C ++ som kallas Anonymous Union ”. Den anonyma fackföreningen kan inte ha typnamnet och ingen variabel av en sådan förening kan skapas. Det är bara för att säga kompilatorn att dess medlemsvariabler ska dela samma plats. Variablen för en anonym union kan hänvisas till utan den normala dot (.) -Operatören.

int main () {union {// definiera anonym union utan typnamn. int x, char c; flottör f; }; x = 10; // hänvisade till unionens variabel med out dot operator cout <

I anonym fack är ingen medlemsfunktion tillåten, den kan inte innehålla privata eller skyddade uppgifter, och den globala anonyma facken måste anges som "statisk".

De punkter att komma ihåg för den normala fackförklaringen.

• Definitionen av en fackförening kan också innehålla konstruktör och destruktor.
• Facket ger flera sätt att visa samma minnesplats.
• Facket kan inte ärva klassen av någon typ.
• Facket kan inte vara en basklass.
• Facket kan inte ha den virtuella medlemsfunktionen.
• Facket kan inte ha en statisk variabel.

1. Strukturen använder olika minnesplatser för olika medlemmar. Därför kan det särskilda värdet tilldelas alla medlemmar. Men facket tilldelar samma minnesplats för alla medlemmar. Därför kan ett enda värde tilldelas alla medlemmar.
2. Strukturen har olika minnesplatser för alla medlemmar; Därför kan den innehålla flera värden åt gången, och eftersom vi vet att facket delar samma minnesplats för alla medlemmar kan den därför lagra ett enda värde åt gången.
3. Generellt sett är den totala storleken på strukturen större än den totala storleken på föreningen eftersom storleken på en struktur är summan av storleken på alla medlemmar i strukturerna och storleken på föreningen är storleken på medlemmen av medlemmen största typ.
4. Struktur ger en enda vy över varje plats medan facket tillhandahåller flera vyer på en enda plats.
5. Du kan förklara en anonym förening men inte en anonym struktur.

Likheter:

• Både struktur och union har samma sätt att deklara sig, skapa variabler och samma sätt att få tillgång till medlemmarna i variablerna.
• Både struktur och förening kan vidarebefordras till en funktion av både metoderna samtal efter värde och samtal genom referens.
• Både struktur och union är behållardatatyp och innehåller ett objekt av vilken datatyp som helst, inklusive annan struktur, union, grupp som sina medlemmar.

Slutsats:

Både struktur och förening är behållardatotypen som innehåller medlemmen av olika typer. Men strukturer används när vi behöver lagra distinkt värde för alla medlemmar på en distinkt minnesplats. Fackföreningarna används när typkonvertering behövs.