Einführung in die verschachtelte Struktur in C
Jede Programmiersprache hat ihre eigene Art, Strukturen zu definieren und zu beschreiben. Verschachtelte Strukturen, wie der Name in C andeutet, definieren also eine Struktur in einer anderen Struktur. Innerhalb einer Struktur können beliebige Elementvariablen definiert werden, die wiederum in eine andere Struktur verschoben werden können. Die Variablen in einer Struktur können wie normal oder Zeiger oder irgendetwas anderes sein und können an einer beliebigen Stelle in der Struktur platziert werden.
Auf verschachtelte Strukturen kann auf zwei Arten zugegriffen werden:
- Struktur innerhalb einer Struktur in C mit der Zeigervariable.
- Struktur innerhalb einer Struktur in C unter Verwendung einer normalen Variablen.
Syntax:
Es folgt die Syntax zum Erstellen einer verschachtelten Struktur:
structure tagname_1
(
var_1;
var_2;
var_3;
.
.
.
.
var n;
structure tagname_2
(
var_1;
var_2;
var_3;
.
.
.
var_n;
), mem1
) mem2;
Arbeiten von verschachtelten Strukturen in C
Aus der obigen Syntax können wir schließen, dass die in der member1-Struktur verschachtelte mem1-Struktur das Element oder die Variable enthält, auf die zugegriffen werden soll, und dass mit verschachtelt auf alle zugegriffen werden kann. (Punkt-) Operator.
- mem2.mem1.var_1: Dies bezieht sich auf das erste Mitglied der Variablen der Struktur tagname_1.
- mem2.mem1.var_2: Dies bezieht sich auf das zweite Mitglied der Variablen der Struktur tagname_2.
Wir werden weitere Beispiele verwenden, um zu verdeutlichen, wie die Syntax die Funktionsweise der verschachtelten Struktur erfüllt.
Beispiele # 1
struct employee
(
struct man
(
char name (20);
int age;
char dob(10);
) d;
int empid;
char desg(10);
) emp;
Im obigen Beispiel wird die Personenstruktur in einer Mitarbeiterstruktur definiert, die eine verschachtelte Struktur ist. Auf Mitglieder innerhalb der verschachtelten Struktur, die ein Mann ist, kann unter Verwendung der folgenden Syntax oder des folgenden Formats zugegriffen werden.
Wie im gegebenen Beispiel
- employee.d .name: Gibt den Namen des Mannes in der Mitarbeiterstruktur an.
- employee.d .age: Es wird über das Alter des Mannes als Angestellter berichtet.
Es ist wichtig, etwas wie diese Struktur zur Kenntnis zu nehmen, das innerhalb der Mitarbeiterstruktur nicht wiederverwendet werden kann, was bedeutet, dass es nirgendwo im gesamten Code erneut aufgerufen werden kann, da es nicht selbst generiert wird.
Eine Problemumgehung dafür kann stattdessen sein:
Wir hätten die Struktur außerhalb definieren und dann die Variable innerhalb der Struktur deklarieren können, wo immer wir im gesamten Code darauf zugreifen möchten.
Beispiele # 2
Struct man
(
char name(20);
int age;
char dob (10);
);
Auch diese Struktur kann von der Außenstruktur wiederverwendet werden.
struct employee
(
struct man info;
int id;
char desg (10);
)
Der Vorteil dieser Art von Strukturdeklaration besteht darin, dass wir überall im Programm eine Variable vom Typ struct man deklarieren können.
Hinweis: Das Verschachteln von Strukturen in sich selbst ist niemals zulässig.Schauen wir uns ein Beispiel an, wie das Verschachteln von Strukturen in sich selbst nicht zulässig ist.
struct teacher
(
char name(20);
char address(100);
int age();
struct teacher principal; // totally invalid way to create nested structure.
)
Beispiele für verschachtelte Strukturen in C
Nachfolgend sind die verschiedenen Beispiele für verschachtelte Strukturen in C aufgeführt:
Beispiel # 1 - Initialisierung verschachtelter Strukturen:
Die Initialisierung verschachtelter Strukturen ist zum Zeitpunkt der Deklaration möglich.
Code:
struct student
(
struct person info;
int rollno;
float marks(10);
)
struct student student_1 = (
("Anji", 26, 1995),
103,
92
);
Beispiel
Code:
#include
struct person
(
char name(20);
int age;
char dob(10);
);
struct student
(
struct person info;
int roll_no;
float marks;
);
int main ()
(
struct student p1;
printf("Details of student: \n\n");
printf("Enter name: ");
scanf("%s", p1.info.name);
printf("Enter age: ");
scanf("%d", &p1.info.age);
printf("Enter dob: ");
scanf ("%s", p1.info.dob);
printf("Enter roll no: ");
scanf("%d", &p1.roll_no);
printf("Enter marks: ");
scanf ("%f", &p1.marks);
printf("\n…………………..\n\n");
printf("Name: %s\n", p1.info.name);
printf("Age: %d\n", p1.info.age);
printf("DOB: %s\n", p1.info.dob);
printf("Roll no: %d\n", p1.roll_no);
printf("Marks: %.2f\n", p1.marks);
return 0;
)
Ausgabe:
Beispiel # 2 - Zugriff auf Mitglieder in verschachtelten Strukturen mit Zeigern:
Code:
#include
#include
struct student_college_info
(
int college_id;
char college_name(50);
);
struct student_info
(
int id;
char name(20);
float percentage;
struct student_college_info clg_data;
) stu_data, *stu_data_ptr;
int main()
(
struct student_info stu_data = (2, "Anu", 92.5, 81145,
"SRM University");
stu_data_ptr = &stu_data;
printf(" Id is: %d \n", stu_data_ptr->id);
printf(" Name is: %s \n", stu_data_ptr->name);
printf(" Percentage is: %f \n\n",
stu_data_ptr->percentage);
printf(" College Id is: %d \n",
stu_data_ptr->clg_data.college_id);
printf(" College Name is: %s \n",
stu_data_ptr->clg_data.college_name);
return 0;
)
Ausgabe:
Beispiel # 3 - Strukturelement als Argumente an function übergeben:
Code:
struct teacher
(
char name (20);
int id;
int marks;
);
void print_struct (char name (), int id, int marks);
int main ()
(
struct teacher tea = ("nidhi", 5, 52);
print_struct (tea.name, tea.id, tea.marks);
return 0;
)
void print_struct (char name (), int id, int marks)
(
printf ("Name: %s\n", name);
printf ("id: %d\n", id);
printf ("Marks: %d\n", marks);
printf("\n");
)
Ausgabe:
Beispiel # 4 - Struktur innerhalb einer Struktur unter Verwendung einer normalen Variablen.
Code:
#include
#include
struct student_college_detail
(
nt college_id;
char college_name(50);
);
struct student_detail
(
int id;
char name(20);
float percentage;
struct student_college_detail clg_data;
) stu_data;
int main()
(
struct student_detail stu_data = (8, "Moam", 50.5, 562345,
"CSS University");
printf(" Id is: %d \n", stu_data.id);
printf(" Name is: %s \n", stu_data.name);
printf(" Percentage is: %f \n\n", stu_data.percentage);
nbsp;
printf(" College Id is: %d \n",
stu_data.clg_data.college_id);
printf(" College Name is: %s \n",
stu_data.clg_data.college_name);
return 0;
)
Ausgabe:
Beispiel
Code:
#include
#include
struct student
(
int id1;
int id2;
char e;
char f;
float percentage;
);
int main ()
(
int i;
struct student recrd1 = (3, 4, 'C', 'B', 80.5);
printf ("size of structure in bytes: %d\n",
sizeof(recrd1));
printf ("\nAddress of id1 = %u", &recrd1.id1);
printf("\nAddress of id2 = %u", &recrd1.id2 );
printf("\nAddress of a = %u", &recrd1.e );
printf("\nAddress of b = %u", &recrd1.f );
printf("\nAddress of percentage = %u”, &recrd1.percentage);
return 0;
)
Ausgabe:
Fazit
Strukturen in C bieten eine sehr interessante Möglichkeit, alle benutzerdefinierten Elementvariablen und -funktionen zu einer Entität zusammenzufassen und zu gruppieren. Trotzdem gibt es einige Einschränkungen: Strukturvariablen und die gesamte Struktur dürfen keine eingebauten Datentypen und keine Operatoren enthalten. Daher können diese Funktionen in naher Zukunft möglicherweise behoben werden.
Empfohlene Artikel
Dies ist eine Anleitung zur geschachtelten Struktur in C. Hier wird die Arbeit in der geschachtelten Struktur in C zusammen mit verschiedenen Beispielen und der Codeimplementierung erläutert. Sie können auch den folgenden Artikel lesen, um mehr zu erfahren -
- Top 11 Funktionen von C ++
- Beispiele für Muster in der C-Programmierung
- Algorithmus der C-Programmiermatrix-Multiplikation
- Bedeutung von C # -Generika