Inleiding tot geneste structuur in C
Elke programmeertaal heeft zijn eigen manier om structuren te definiëren en te beschrijven. Dus geneste structuren zoals de naam suggereert in C, is een soort van het definiëren van de ene structuur in een andere structuur. Alle lidvariabelen kunnen binnen een structuur worden gedefinieerd en op zijn beurt kan die structuur verder naar een andere structuur worden verplaatst. De variabelen in een structuur kunnen van alles zijn zoals normaal of aanwijzer of iets en kunnen overal in de structuur worden geplaatst.
De geneste structuur kan op twee manieren worden geopend:
- Structuur binnen een structuur in C met behulp van de pointervariabele.
- Structuur binnen een structuur in C met behulp van een normale variabele.
Syntaxis:
Hierna volgt de syntaxis voor het maken van een geneste structuur:
structure tagname_1
(
var_1;
var_2;
var_3;
.
.
.
.
var n;
structure tagname_2
(
var_1;
var_2;
var_3;
.
.
.
var_n;
), mem1
) mem2;
Werken van geneste structuur in C
Uit de bovenstaande syntaxis kunnen we afleiden dat de mem1-structuur die is genest in de structuur van het lid1 het lid of de variabele bevat waartoe toegang moet worden verkregen en dat iedereen op een geneste manier kan worden benaderd met behulp van. (punt) operator.
- mem2.mem1.var_1: dit verwijst naar het eerste lid van de variabele van de structuur tagname_1.
- mem2.mem1.var_2: dit verwijst naar het tweede lid van de variabele van de structuur tagname_2.
We zullen meer voorbeelden nemen om duidelijkheid te krijgen over hoe de syntaxis voldoet aan de werking van de geneste structuur.
Voorbeelden # 1
struct employee
(
struct man
(
char name (20);
int age;
char dob(10);
) d;
int empid;
char desg(10);
) emp;
In het bovenstaande voorbeeld wordt de manstructuur gedefinieerd binnen een werknemersstructuur die een geneste structuur is. Leden binnen de geneste structuur die een man is, kunnen worden geopend met behulp van de onderstaande syntaxis of indeling.
Zoals in het gegeven voorbeeld
- employee.d .name: het vertelt de naam van de man in de werknemersstructuur.
- medewerker.d. leeftijd: het zal vertellen over de leeftijd van de man als werknemer.
Het is belangrijk om iets als deze structuur onder de aandacht te brengen dat een man binnen de werknemersstructuur niet opnieuw kan worden gebruikt, wat betekent dat het nergens in de hele code opnieuw kan worden aangeroepen omdat het niet zelf is gegenereerd.
In plaats daarvan kan een oplossing hiervoor zijn:
We hadden de structuur buiten kunnen definiëren en dan de variabele binnen de structuur kunnen declareren waar we er in de code toegang toe willen krijgen.
Voorbeelden # 2
Struct man
(
char name(20);
int age;
char dob (10);
);
Ook kan deze structuur worden hergebruikt door de buitenste structuur.
struct employee
(
struct man info;
int id;
char desg (10);
)
Het voordeel van het gebruik van dit type structuurdeclaratie is dat we overal in het programma een variabele van type struct man kunnen declareren.
Opmerking: het nesten van structuur in zichzelf is nooit toegestaan.Laten we een voorbeeld bekijken van hoe het nesten van structuur in zichzelf niet is toegestaan.
struct teacher
(
char name(20);
char address(100);
int age();
struct teacher principal; // totally invalid way to create nested structure.
)
Voorbeelden van geneste structuren in C
Hieronder staan de verschillende voorbeelden van geneste structuur in C:
Voorbeeld # 1 - Initialisatie van geneste structuren:
Initialisatie van geneste structuren is mogelijk op het moment van aangifte.
Code:
struct student
(
struct person info;
int rollno;
float marks(10);
)
struct student student_1 = (
("Anji", 26, 1995),
103,
92
);
Voorbeeld
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;
)
Output:
Voorbeeld # 2 - Toegang tot leden in geneste structuur met behulp van Pointers:
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;
)
Output:
Voorbeeld # 3 - Structuurlid doorgeven als argumenten om te functioneren:
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");
)
Output:
Voorbeeld # 4 - Structuur in structuur met behulp van een normale variabele.
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;
)
Output:
Voorbeeld
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;
)
Output:
Conclusie
Structuren in C is een zeer interessante manier om alle door de gebruiker gedefinieerde lidvariabelen en -functies te clusteren en te groeperen in één entiteit. Maar toch, het heeft enkele beperkingen alsof het niet toestaat dat structuurvariabelen en de volledige structuur de ingebouwde gegevenstypen bevatten en geen gebruik van operatoren. Daarom kan in de nabije toekomst misschien voor deze functies worden gezorgd.
Aanbevolen artikelen
Dit is een gids voor de geneste structuur in C. Hier bespreken we de werking in geneste structuur in C samen met verschillende voorbeelden en code-implementatie. U kunt ook het volgende artikel bekijken voor meer informatie -
- Top 11 kenmerken van C ++
- Voorbeelden van patronen in C-programmering
- Algoritme van C-programmeermatrixvermenigvuldiging
- Het belang van C # Generics