Union kann als benutzerdefinierter Datentyp definiert werden, bei dem es sich um eine Sammlung verschiedener Variablen unterschiedlicher Datentypen am selben Speicherort handelt. Die Union kann auch als viele Mitglieder definiert werden, aber nur ein Mitglied kann zu einem bestimmten Zeitpunkt einen Wert enthalten.
Basisband vs. Breitband
Union ist ein benutzerdefinierter Datentyp, aber im Gegensatz zu Strukturen teilen sie sich den gleichen Speicherort.
Lassen Sie uns dies anhand eines Beispiels verstehen.
struct abc { int a; char b; } Der obige Code ist die benutzerdefinierte Struktur, die aus zwei Mitgliedern besteht, d. h. dem Typ „a“. int und 'b' vom Typ Charakter . Als wir die Adressen von „a“ und „b“ überprüften, stellten wir fest, dass ihre Adressen unterschiedlich sind. Wir kommen daher zu dem Schluss, dass die Mitglieder in der Struktur nicht denselben Speicherort teilen.
Als wir die Union definierten, stellten wir fest, dass Union auf die gleiche Weise definiert wird wie die Struktur. Der Unterschied besteht jedoch darin, dass das Schlüsselwort Union zum Definieren des Union-Datentyps verwendet wird, während das Schlüsselwort struct zum Definieren der Struktur verwendet wird. Die Union enthält die Datenelemente „a“ und „b“. Als wir die Adressen beider Variablen überprüften, stellten wir fest, dass beide die gleichen Adressen haben. Dies bedeutet, dass die Gewerkschaftsmitglieder denselben Speicherort teilen.
Werfen wir einen Blick auf die bildliche Darstellung der Speicherbelegung.
Die folgende Abbildung zeigt die bildliche Darstellung der Struktur. Die Struktur besteht aus zwei Mitgliedern; Das heißt, einer ist vom Typ „Integer“ und der andere vom Typ „Zeichen“. Da 1 Block 1 Byte entspricht; Daher werden der Variablen „a“ 4 Speicherblöcke zugewiesen, während der Variablen „b“ 1 Speicherblock zugewiesen wird.
Die folgende Abbildung zeigt die bildliche Darstellung von Gewerkschaftsmitgliedern. Beide Variablen teilen sich denselben Speicherort und haben dieselbe Anfangsadresse.
In der Union teilen sich die Mitglieder den Speicherort. Wenn wir versuchen, Änderungen an einem Mitglied vorzunehmen, wird dies auch auf das andere Mitglied übertragen. Lassen Sie uns dieses Konzept anhand eines Beispiels verstehen.
union abc { int a; char b; }var; int main() { var.a = 66; printf('
a = %d', var.a); printf('
b = %d', var.b); } Im obigen Code hat Union zwei Mitglieder, nämlich „a“ und „b“. Die 'var' ist eine Variable vom Typ Union abc. Im hauptsächlich() Bei dieser Methode weisen wir der Variablen „a“ die Zahl 66 zu, sodass var.a 66 auf dem Bildschirm ausgibt. Da sowohl „a“ als auch „b“ den Speicherort teilen, var.b wird drucken ' B ' (ASCII-Code von 66).
Festlegung der Größe der Gewerkschaft
Die Größe der Gewerkschaft richtet sich nach der Größe des größten Gewerkschaftsmitglieds.
Lassen Sie es uns anhand eines Beispiels verstehen.
union abc{ int a; char b; float c; double d; }; int main() { printf('Size of union abc is %d', sizeof(union abc)); return 0; } Wie wir wissen, beträgt die Größe von int 4 Bytes, die Größe von char 1 Byte, die Größe von float 4 Bytes und die Größe von double 8 Bytes. Da die Double-Variable von allen vier Variablen den größten Speicher belegt, werden insgesamt 8 Bytes im Speicher zugewiesen. Daher wäre die Ausgabe des obigen Programms 8 Bytes.
Zugriff auf Gewerkschaftsmitglieder mithilfe von Zeigern
Wir können über Zeiger auf die Mitglieder der Union zugreifen, indem wir den Pfeiloperator (->) verwenden.
Lassen Sie es uns anhand eines Beispiels verstehen.
#include union abc { int a; char b; }; int main() { union abc *ptr; // pointer variable declaration union abc var; var.a= 90; ptr = &var; printf('The value of a is : %d', ptr->a); return 0; } Im obigen Code haben wir eine Zeigervariable erstellt, nämlich *ptr, die die Adresse der Variablen var speichert. Jetzt kann ptr mithilfe des (->)-Operators auf die Variable „a“ zugreifen. Daher wäre die Ausgabe des obigen Codes 90.
Warum brauchen wir C-Gewerkschaften?
Betrachten Sie ein Beispiel, um die Notwendigkeit von C-Gewerkschaften zu verstehen. Betrachten wir ein Geschäft mit zwei Artikeln:
- Bücher
- Hemden
Ladenbesitzer möchten die Aufzeichnungen der beiden oben genannten Artikel zusammen mit den relevanten Informationen speichern. Zu „Bücher“ gehören beispielsweise Titel, Autor, Seitenanzahl und Preis, und zu „Hemden“ gehören Farbe, Design, Größe und Preis. Die Eigenschaft „Preis“ ist beiden Artikeln gemeinsam. Der Ladenbesitzer möchte die Eigenschaften speichern und dann festlegen, wie er/sie die Datensätze speichern wird.
Zunächst entschieden sie sich, die Datensätze in einer Struktur wie unten dargestellt zu speichern:
struct store { double price; char *title; char *author; int number_pages; int color; int size; char *design; }; Die obige Struktur besteht aus allen Artikeln, die der Ladenbesitzer lagern möchte. Die obige Struktur ist vollständig verwendbar, aber der Preis ist gemeinsames Eigentum beider Artikel und die übrigen Artikel sind individuell. Die Eigenschaften wie Preis, *Titel, *Autor und Anzahl_Seiten gehören zu Büchern, während Farbe, Größe und *Design zu Hemd gehören.
dijkstra
Sehen wir uns an, wie wir auf die Mitglieder der Struktur zugreifen können .
int main() { struct store book; book.title = 'C programming'; book.author = 'Paulo Cohelo'; book.number_pages = 190; book.price = 205; printf('Size is : %ld bytes', sizeof(book)); return 0; } Im obigen Code haben wir eine Variable vom Typ erstellt speichern . Wir haben den Variablen Titel, Autor, Anzahl_Seiten und Preis die Werte zugewiesen, aber die Buchvariable besitzt nicht die Eigenschaften wie Größe, Farbe und Design. Daher ist es eine Verschwendung von Speicher. Die Größe der obigen Struktur würde 44 Byte betragen.
Wir können viel Platz sparen, wenn wir Gewerkschaften verwenden.
#include struct store { double price; union { struct{ char *title; char *author; int number_pages; } book; struct { int color; int size; char *design; } shirt; }item; }; int main() { struct store s; s.item.book.title = 'C programming'; s.item.book.author = 'John'; s.item.book.number_pages = 189; printf('Size is %ld', sizeof(s)); return 0; } Im obigen Code haben wir eine Variable vom Typ Store erstellt. Da wir im obigen Code die Vereinigungen verwendet haben, wird der größte von der Variable belegte Speicher für die Speicherzuweisung berücksichtigt. Die Ausgabe des obigen Programms beträgt 32 Bytes. Bei Strukturen haben wir 44 Bytes erhalten, während bei Unions die Größe 44 Bytes beträgt. Daher sind 44 Byte größer als 32 Byte und sparen viel Speicherplatz.