Wie man eine Reihe von Strukturen in C erstellt

Wir werden zuerst die Strukturen in C verstehen und dann über die Auswahl der Strukturen in C diskutieren. Wir werden auch die Reihe von Strukturzeigern durchlaufen und wie wir auf die Strukturelemente innerhalb des Arrays von Strukturobjekten zugreifen können.

Strukturen sind die benutzerdefinierte Gruppe ähnlicher oder unterschiedlicher Datentypen. Eine ähnliche oder unterschiedliche Gruppe von Datentypen kann unter einem Namen als Strukturen gruppiert werden. Beispielstrukturerklärung in C:

Struktur ABC
Int a;
Char B;
Float c;
;

Um Objekt aus der Strukturerklärung zu erstellen, finden Sie hier die Syntax in C, um dies zu tun:

Struktur ABC OBJ;

Mit dieser Objekterstellung wird der Struktur Speicher zugeordnet. Um mit Hilfe von Objekt (OBJ) auf das Mitglied von Strukturen zuzugreifen, kann er als:

Obj.a = 10; obj.B = 'C'; obj.C = 1.0;

Dies ist der Fall, wenn das Objekt erstellt wird. Es besteht keine Notwendigkeit, einen Speicher zuzuweisen. Sobald das Objekt instanziiert ist, wird der Speicher automatisch zugewiesen.

Die Zuweisung des Speichers in die Struktur kann zur Laufzeit durchgeführt werden. Für die Laufzeitzuweisung kann die Malloc -Funktion verwendet werden.

Es wird eine Zeigererklärung auf die Struktur geben. Die Erklärung des Zeigers auf die Struktur kann als Struktur ABC *PTR durchgeführt werden; Mit dieser Erklärung wird es keine Zuordnung eines Speichers an das Strukturobjekt geben. Die Malloc -Funktion sollte verwendet werden, um Speicher zuzuweisen, und unten ist die Syntax dazu:

Struktur ABC *ptr;
ptr = malloc (sizeof (struct ABC));

Jetzt wird PTR den Speicher zuweisen. Es kann die Daten für Mitgliedselemente der Struktur speichern.

Um mit Hilfe von Zeigern auf die Strukturmitglieder zuzugreifen, kann dies wie folgt durchgeführt werden:

Ptr-> a = 10; ptr-> b = 'c'; ptr-> c = 2.0;

Bisher haben wir das einzelne Strukturobjekt besprochen. Sowohl die Möglichkeiten des Zugangs von Mitgliedselementen, wir haben durch Zeiger als auch den direkten Zugriff mit Objekten gesehen.

Wir haben zwei Möglichkeiten, die Strukturen zu definieren. Erstens ist es, das Strukturobjekt zu definieren. Eine andere Möglichkeit besteht darin, den Zeiger auf die Struktur zu definieren.

Strukturobjekt: Struktur ABC OBJ;
Strukturzeiger: Struktur ABC *ptr;

Lassen Sie uns nun das Array von Strukturobjekten und das Array von Strukturzeigern diskutieren. Array ist eine Gruppe von Objekten des gleichen Typs. Zum Beispiel wird eine Reihe von OBJ als Struktur ABC OBJ deklariert [128]. Das Array von Zeigern auf die Strukturobjekte ist als Struktur ABC *PTR [128]. Sowohl das Array definierte die 128 Elemente von Strukturobjekten und Zeigern.

C Programm zum Deklarieren von Strukturobjekten:

#enthalten
Struktur ABC
int a;
Char B;
float c;
;
int main ()

Struktur ABC obj = 1, 'c', 3.4;
printf ("a =%d, b =%c, c =%f \ n", obj.A, obj.B, obj.C);
Rückkehr 0;

Ausgang:

Bash-4.2 $ ./A.aus
a = 1, b = c, c = 3.400000
Bash-4.2 $

Das obige Programm definiert das Objekt der Struktur und eine Möglichkeit, das Mitglied zu initialisieren und das Objekt zu deklarieren. Wir initialisieren die Mitgliedsvariablen mit spezifischen Werten und drucken diese Variablen, indem wir auf die Mitglieder mit Objekt direkt zugreifen. A wird mit 1 zugewiesen, b mit 'c' zugeordnet und C mit dem Float -Wert 3 zugeordnet.4. Unten finden Sie die Schnappscheide des Programms und der Ausgabe.

Schnappschuss:

C Programm, um den Zeiger auf die Struktur zu deklarieren:

#enthalten
Struktur ABC
int a;
Char B;
float c;
;
int main ()

Struktur ABC *ptr;
ptr = malloc (sizeof (struct ABC));
ptr-> a = 4;
ptr-> b = 'd';
ptr-> c = 5.5;
printf ("a =%d, b =%c, c =%f \ n", ptr-> a, ptr-> b, ptr-> c);
Rückkehr 0;

Ausgang:

Bash-4.2 $ ./A.aus
a = 4, b = d, c = 5.500000
Bash-4.2 $

Das obige Programm definiert den Zeiger auf Objekt der Struktur. Die Malloc -Funktion wird verwendet, um Speicher für die Zeigervariable zuzuweisen. Wir initialisieren die Mitgliedsvariablen mit spezifischen Werten und drucken diese Variablen, indem wir mit Zeiger auf die Mitglieder zugreifen. A wird mit 4 zugewiesen, B wird mit 'D' zugeordnet und C mit dem Float -Wert 5 zugeordnet.5. Unten finden Sie die Schnappscheide des Programms und der Ausgabe.

Schnappschuss:

Lassen Sie uns nun das C -Programm für eine Reihe von Strukturen und eine Reihe von Zeigern auf Strukturen durchlaufen.

C Programm für eine Array der Struktur von Objekten:

#enthalten
Struktur ABC
int a;
Char B;
float c;
;
int main ()

Struktur Abcobj [2];
OBJ [0].a = 4;
OBJ [0].B = 'D';
OBJ [0].C = 5.5;
OBJ [1].a = 5;
OBJ [1].B = 'f';
OBJ [1].C = 8.2;
printf ("[0] a =%d, [0] b =%c, [0] c =%f \ n", obj [0].A, OBJ [0].B, OBJ [0].C);
printf ("[1] a =%d, [1] b =%c, [1] c =%f \ n", OBJ [1].A, OBJ [1].B, OBJ [1].C);
Rückkehr 0;

Ausgang:

Bash-4.2 $ ./A.aus
[0] a = 4, [0] b = d, [0] c = 5.500000
[1] a = 5, [1] b = f, [1] c = 8.200000
Bash-4.2 $

Das obige Programm definiert das Array des Objekts der Struktur und eine Möglichkeit, die Mitglieder mit Hilfe von Objekten zu initialisieren. Wir initialisieren die Mitgliedsvariablen mit spezifischen Werten und drucken diese Variablen, indem wir auf die Mitglieder mit Objekt direkt zugreifen. Der Einfachheit halber haben wir nur 2 Objekte genommen. Das erste Objekt ist mit 4, B mit 'D' zugeordnet und C mit dem Float -Wert 5 zugewiesen.5. Der zweite Objekt ist mit 5, B mit 'f' zugeordnet und C mit dem Float -Wert 8 zugeordnet.2. Unten finden Sie die Schnappscheide des Programms und der Ausgabe.

Schnappschuss:

C Programm für eine Reihe von Zeigern auf die Struktur von Objekten:

#enthalten
Struktur ABC
int a;
Char B;
float c;
;
int main ()

Struktur ABC *PTR [2];
ptr [0] = malloc (sizeof (struct ABC));
ptr [1] = malloc (sizeof (struct ABC));
PTR [0]-> A = 4;
PTR [0]-> B = 'D';
PTR [0]-> C = 5.5;
PTR [1]-> A = 5;
PTR [1]-> B = 'F';
PTR [1]-> C = 8.2;
printf ("[0] a =%d, [0] b =%c, [0] c =%f \ n", ptr [0]-> A, PTR [0]-> B, PTR [0] -> c);
printf ("[1] a =%d, [1] b =%c, [1] c =%f \ n", ptr [1]-> a, ptr [1]-> b, ptr [1] -> c);
Rückkehr 0;

Ausgang:

Bash-4.2 $ ./A.aus
[0] a = 4, [0] b = d, [0] c = 5.500000
[1] a = 5, [1] b = f, [1] c = 8.200000
Bash-4.2 $

Das obige Programm definiert die Reihe von Zeigern auf Objekt der Struktur und eine Möglichkeit, die Mitglieder mit Hilfe von Zeigern zu initialisieren. Wir initialisieren die Mitgliedsvariablen mit spezifischen Werten und drucken diese Variablen, indem wir auf die Mitglieder mit Zeigervariablen zugreifen. Der Einfachheit halber haben wir nur 2 Zeiger genommen. Der erste Zeiger auf Objekt A wird mit 4 zugewiesen, B wird mit 'D' zugewiesen und C wird mit dem Float -Wert 5 zugewiesen.5. Der zweite Zeiger auf Objekt A wird mit 5 zugewiesen, B wird mit 'f' zugeordnet und C mit Float -Wert 8 zugewiesen.2. Unten finden Sie die Schnappscheide des Programms und der Ausgabe.

Schnappschüsse:

Abschluss:

Wir haben den Strukturdatentyp in C und die Möglichkeiten zur Deklaration der Objekte und Zeiger auf die Struktur von Objekten besprochen. Wir haben auch einige Beispiele und mit Ausgang besprochen. Sowohl die Objekte als auch die Zeiger wurden diskutiert. Die Array von Objekten und Zeiger auf Objekte wurden ebenfalls mit Beispielen diskutiert.