C/C++ Schritt-für-Schritt - Seite 10

10. Schritt-für-Schritt C/C++ — C Programmierung - Struktur

Strukturen

| | 1. Einführung

2. Deklaration der Struktur
3. Definition einer Strukturvariablen
4. Initialisierung einer Strukturvariablen
5. Direkte Zuweisung von Strukturen
6. Berechnung der Strukturgröße
7. Verschachtelte Strukturen
8. Array von Strukturen
9. Arrays innerhalb von Strukturen
10. Übergabe von Strukturen an Funktionen
11. Rückgabe von Strukturen aus Funktionen
12. Zeiger auf Struktur
13. Struktur mit Zeigern
14. Selbstreferenzielle Strukturen |

1. Einführung

| | int a[4] = { 3, 4, 5, 6 };                / Gültiger Ausdruck /
int a[4] = { 3, 4.23, 5, 6 };                / Ungültiger Ausdruck /
int a[4] = { 3, “Siglov”, 5,3}                / Ungültiger Ausdruck / |

Warum sind die letzten beiden Ausdrücke ungültig? Ein Array kann Werte des gleichen Typs speichern. Es muss der gleiche Typ sein. Eine Struktur kann jedoch mehr als einen Datentyp gemäß ihrer Definition enthalten.

| | • Eine Gruppe von einem oder mehreren Variablen unterschiedlicher Datentypen, die unter einem einzigen Namen organisiert sind, wird als Struktur bezeichnet oder
• Eine Sammlung von heterogenen (ungleichartigen) Datentypen, die unter einem einzigen Namen gruppiert sind, wird als Struktur bezeichnet oder
• Eine Struktur ist eine Sammlung einfacher Variablen. Die Variablen in einer Struktur können unterschiedliche Typen haben. Die Datenelemente in einer Struktur werden als Mitglieder der Struktur bezeichnet. |

2. Deklaration einer Struktur

Wenn eine Struktur definiert wird, wird die gesamte Gruppe über den Strukturnamen referenziert. Die einzelnen Komponenten, die in der Struktur vorhanden sind, werden als Strukturmitglieder bezeichnet und können separat zugegriffen und verarbeitet werden.

| | |

Bsp:

| | struct date
{
int day;
int month;
int year;
}; | struct student
{
int sno;
char name[20];
int marks;
float avg;
}; |

3. Definition einer Strukturvariablen

Die Definition einer Strukturvariablen ist die gleiche wie die Definition eines eingebauten Datentyps wie int.

| | int a;                             /  gültig /
date d;                          / gültig (aber nur in C++) /
struct date d;                 / gültig in C und C++  / |

4. Initialisierung einer Strukturvariablen

Die Mitglieder der Struktur können wie andere Variablen initialisiert werden. Dies kann zum Zeitpunkt der Deklaration oder zur Entwurfszeit erfolgen.

| 1. Initialisierung bei der Deklaration:
struct ddate
{
int day;
int month;
int year;
} d = { 27, 10, 2000 }; | 2. Initialisierung bei der Definition:
struct ddate d = { 27, 10, 2000 }; | | 1. Initialisierung zur Entwurfszeit: ddate d;
d.day = 27;
d.month = 10;
d.year = 2000; | 4. Initialisierung zur Laufzeit:
scanf(“%d%d%d”, &d.day, &d.month, &d.year); |

Bsp:

| | / Schreiben Sie ein Programm, um die Details eines Mitarbeiters zu akzeptieren und auszudrucken /
/ 73_struct.c /
#include
struct emp
{
int eno;
char name[20];
float sal;
};
int main()
{
struct emp e;

printf(“Geben Sie die Mitarbeiternummer ein    :”); scanf(“%d”, &e.eno);
printf(“Geben Sie den Mitarbeiternamen ein       :”); scanf(“%s”, e.name);
printf(“Geben Sie das Mitarbeitergehalt ein      :”); scanf(“%d”, &e.sal);
printf(“\n\nMitarbeiterdetails sind wie folgt…. “);
printf(“%d    %s      %d”, e.eno, e.name, e.sal);
return 0;
} |

5. Direkte Zuweisung von Strukturen

Die direkte Zuweisung von mehr als einer Variablen wird durch die Verwendung von Strukturen ermöglicht.

| | struct emp a, b = {1001, “Vimal”, 6700.00 };
a = b; / Gültig /
printf(“%d %s %d” , a.eno, a.name, a.sal ); | | | Ausgabe:
1001 Vimal 6700.00 |

6. Berechnung der Strukturgröße

Jeder Datentyp in C/C++ hat eine festgelegte Größe, d.h. int hat 2 Bytes Größe, float hat 4 Bytes Größe und so weiter. Hier ist die Methode, um die Größe einer Strukturvariablen zu finden.

sizeof:- Diese Funktion wird verwendet, um die Größe einer gegebenen Variablen zu finden.

| | printf(“%d”, sizeof(int));                           / 2  /
printf(“%d”, sizeof(float));                       / 4  /
printf(“%d”, sizeof(struct emp));              / Zeigt die Größe der emp-Struktur an / |

7. Verschachtelte Strukturen

Strukturen innerhalb von Strukturen werden als verschachtelte Strukturen bezeichnet. Um auf die Mitglieder der verschachtelten Struktur zuzugreifen, müssen wir den Punktoperator zweimal anwenden, um auf die Mitglieder der aufrufenden Struktur zuzugreifen.

Bsp:

| | / Programm zur Demonstration der verschachtelten Struktur mit der Mitarbeiterstruktur /
/ 74_nested.c /
#include
struct emp
{
int eno;
char name[10];
float sal;
struct                                                    / Verschachtelte Struktur  /
{
street char[10];
city char[10];
} addr;
};
int main()
{
struct emp e;
printf(“Geben Sie emp_no, emp_name, emp_sal, street, city ein “);
scanf(“%d%s%d%s%s”, &e.eno, e.name, &e.sal, e.addr.street, e.addr.city );
printf(“\n\nMitarbeiterdetails sind wie folgt   …. “);
printf(“%d%s%d%s%s”, e.eno, e.name, e.sal, e.addr.street, e.addr.city );
return 0;
} |

8. Array von Strukturen

Wir können ein Array von Strukturen erstellen. Das Array hat individuelle Strukturen als seine Elemente.

| | / Schreiben Sie ein Programm, um die Details eines Mitarbeiters zu akzeptieren und auszudrucken /
/ 75_array.c  /
#include
struct emp
{
int eno;
char name[20];
float sal;
};
int main()
{
struct emp e [10];
int i;
for(i = 0; i<10; i++)
{
printf(“Geben Sie die Mitarbeiternummer ein    :”); scanf(“%d”, &e [i].eno);
printf(“Geben Sie den Mitarbeiternamen ein       :”); scanf(“%s”, e [i].name);
printf(“Geben Sie das Mitarbeitergehalt ein     :”); scanf(“%d”, &e [i].sal);
}
printf(“\n\nMitarbeiterdetails sind wie folgt…. “);
for(i = 0; i<10; i++)
printf(“%d    %s      %d”, e [i].eno, e [i].name, e [i].sal);
return 0;
} |

Nichts ist neu im obigen Programm. Das gesamte Programm ist dasselbe wie das einfache strukturierte Programm, mit Ausnahme der markierten Daten.

9. Arrays innerhalb von Strukturen

Es kann eine Situation geben, in der Arrays innerhalb von Strukturen genutzt werden müssen. Wie man Arrays innerhalb von Strukturen erreicht. Hier ist der Ansatz mit einem einfachen Programm.

| | / Programm zur Annahme und Ausgabe von Studentendaten  /
/ 76_array.c /
#include
struct stud
{
int sno;
char name[10];
int marks[5];                              / Array innerhalb der Struktur /
};
int main()
{
struct stud s;
int i;
printf(“Geben Sie die Studentennummer ein  “); scanf(“%d”, &s.sno);
printf(“Geben Sie den Studentennamen ein          “); scanf(“%d”, s.name);
for( i = 0; i<3; i++)
{
printf(“Geben Sie die Noten des Studenten ein  “); scanf(“%d”, &s.marks[i]);
}
printf(“\n\nStudentenunterlagen sind wie folgt…. “);
printf(“%d  %s  %d  %d  %d”, s.sno, s.name, s.marks[0], s.marks[1], s.marks[2] );
return 0;
} |

10. Übergabe von Strukturen an Funktionen

Es ist möglich, gesamte Strukturen als Argumente im Funktionsaufruf an Funktionen zu übergeben. Die Strukturvariable wird wie jede gewöhnliche Variable behandelt.

| | / Programm zur Übergabe einer Strukturvariablen an eine Funktion /
/ 77_funct.c /
#include
struct emp
{
int eno;
char name[10];
float sal;
};
void display(struct emp temp);
int main()
{
struct emp e;
display(e);
return 0;
}
void display(struct emp temp)
{
printf(“%d  %s  %d”, temp.eno, temp.name, temp.sal );
} |

11. Rückgabe von Strukturen aus Funktionen

Wir können Strukturen aus Funktionen zurückgeben. Ja, Strukturen können aus Funktionen zurückgegeben werden, genau wie Variablen eines anderen Typs.

| | / Rückgabe eines Strukturobjekts aus einer Funktion /
/ 78_funct.c /
struct emprec
{
int eno;
char name[10];
};
struct emprec read();
void write(struct emprec t);
int main()
{
struct emprec e;
e = read();
write(e);
return 0;
}
void write(struct emprec t)
{
printf(“\n\n%d  %s”, t.eno, t.name);
}
struct emprec read()
{
struct emprec t;
printf(“Geben Sie die Mitarbeiternummer ein   :”); scanf(“%d”, &t.eno);
printf(“Geben Sie den Mitarbeiternamen ein         :”); scanf(“%s”, t.name);
return t;
} |

12. Zeiger auf Struktur

Bis jetzt haben wir gesehen, dass die Mitglieder einer Struktur Datentypen wie int, char, float oder sogar Struktur sein können. Die C/C++-Sprache erlaubt auch die Deklaration einer Zeigervariablen als Mitglied einer Struktur. Zeigervariablen können auch verwendet werden, um die Adresse einer Strukturvariablen zu speichern. Ein Zeiger kann deklariert werden, als ob er auf einen Strukturdatentyp zeigt.

| | / Programm zur Demonstration des Prozesses des Zeigers auf Struktur /
/ 79_pointer.c /
#include
struct employee
{
int eno;
char name[10];
};
struct employee emp;
int main()
{
emp = (struct employee )malloc(sizeof(emp));
printf(“Geben Sie die Mitarbeiterdetails ein ..”);
scanf(“%d%s%”, &emp->eno, emp->name);
printf(“\n\n%d   %s”, emp->eno, emp->name);
return 0;
} |

Die markierten Daten sind entscheidend, um einen Zeiger auf eine Struktur zu implementieren.
Die folgende Anweisung ist optional, aber es ist besser, sie zu nutzen, um ein besseres Speichermanagement zu organisieren.
emp = (struct employee * )malloc(sizeof(emp));

13. Strukturen mit Zeigern

Eine Zeigervariable kann auch als Mitglied in der Struktur verwendet werden.
Das folgende Programm enthält Zeigermitglieder, die von einer Zeigervariablen der Struktur enthalten sind.

| | / Programm zur Demonstration der Verwendung von Strukturen mit Zeigern /
/ 80_pointers.c  /
#include
struct
{
int a;
int b;
} *temp;
int main()
{
int x, y;
x = 20; y = 50;
rk -> a = &x;
rk -> b = &y;

printf(“%d %d “, temp->a, temp->b );
return 0;
} | | | Ausgabe:
20    50 |

14. Selbstreferenzielle Strukturen

Strukturen können Mitglieder haben, die vom Typ der gleichen Struktur sind, in der sie enthalten sind. Dies ist mit Zeigern möglich, und das Phänomen wird als selbstreferenzielle Strukturen bezeichnet.

| | struct emp
{
int eno;
char name[10];
struct emp *e;
}; |

Selbstreferenzielle Strukturen können hauptsächlich verwendet werden, um Daten zu organisieren, Elemente zu sortieren, zu suchen, Elemente einzufügen, zu löschen und so weiter.

Dieser Ansatz führt zu Datenstrukturen (d.h. verkettete Listen, Stacks, Warteschlangen, Bäume und Graphen).