Introducere în structura cuibărită în C
Orice limbaj de programare are propriul mod de a defini și descrie structuri. Așadar, structurile imbricate așa cum sugerează numele lui în C este un fel de definire a unei structuri în interiorul altei structuri. Orice variabile de membru pot fi definite în interiorul unei structuri și, la rândul său, acea structură poate fi mutată în continuare într-o altă structură. Variabilele din interiorul unei structuri pot fi orice precum normalul sau indicatorul sau orice și pot fi plasate oriunde în cadrul structurii.
Structura cuibărită poate fi accesată în două moduri:
- Structurați în interiorul unei structuri în C folosind variabila pointer.
- Structurați în interiorul unei structuri în C folosind o variabilă normală.
Sintaxă:
Urmează sintaxa pentru crearea unei structuri imbricate:
structure tagname_1
(
var_1;
var_2;
var_3;
.
.
.
.
var n;
structure tagname_2
(
var_1;
var_2;
var_3;
.
.
.
var_n;
), mem1
) mem2;
Funcționarea structurii cuiburi în C
Din sintaxa de mai sus, putem deduce faptul că structura mem1 cuibărită în structura membrului1 va conține membrul sau variabila de accesat și toată lumea poate fi accesată în mod cuibărit folosind. (punct) operator.
- mem2.mem1.var_1: Aceasta se referă la primul membru al variabilei structurii tagname_1.
- mem2.mem1.var_2: Aceasta se referă la cel de-al doilea membru al variabilei structurii tagname_2.
Vom lua mai multe exemple pentru a obține claritate asupra modului în care sintaxa satisface funcționarea structurii imbricate.
Exemple # 1
struct employee
(
struct man
(
char name (20);
int age;
char dob(10);
) d;
int empid;
char desg(10);
) emp;
În exemplul de mai sus, structura omului este definită în interiorul unei structuri de angajați care este o structură cuibărită. Membrii din structura cuibărită care este un om pot fi accesați utilizând sintaxa sau formatul de mai jos.
Ca în exemplul dat
- angajat.d. nume: Vorbeste despre numele barbatului din structura angajatului.
- angajat.d .age: Va povesti despre vârsta bărbatului ca angajat.
Este important să notăm un lucru precum această structură omul din structura angajaților nu poate fi reutilizat, ceea ce înseamnă că nu poate fi apelat din nou oriunde pe întregul cod, deoarece nu este auto-generat.
În schimb, o soluție pentru acest lucru poate fi:
Am fi putut defini structura din exterior și apoi am fi putut declara variabila în interiorul structurii oriunde dorim să o accesăm în întregul cod.
Exemple # 2
Struct man
(
char name(20);
int age;
char dob (10);
);
De asemenea, această structură poate fi reutilizată de structura exterioară.
struct employee
(
struct man info;
int id;
char desg (10);
)
Avantajul utilizării acestui tip de declarație de structură este că putem declara o variabilă de tip struct om oriunde pe parcursul programului.
Notă: Niciodată nu este permisă cuibarea structurii în sine.Să vedem un exemplu despre modul în care cuibarea structurii în sine nu este permisă.
struct teacher
(
char name(20);
char address(100);
int age();
struct teacher principal; // totally invalid way to create nested structure.
)
Exemple de structuri cuiburi în C
Mai jos sunt diferite exemple de structură cuibărită în C:
Exemplul # 1 - Initializarea structurilor imbricate:
Inițializarea structurilor cuibare este posibilă la momentul declarației.
Cod:
struct student
(
struct person info;
int rollno;
float marks(10);
)
struct student student_1 = (
("Anji", 26, 1995),
103,
92
);
Exemplu
Cod:
#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;
)
ieşire:
Exemplul # 2 - Accesarea membrilor în structura cuibărită folosind indicatoarele:
Cod:
#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;
)
ieşire:
Exemplul # 3 - Trecerea membrului structurii ca argumente pentru a funcționa:
Cod:
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");
)
ieşire:
Exemplul # 4 - Structura în interiorul structurii folosind o variabilă normală.
Cod:
#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;
)
ieşire:
Exemplu
Cod:
#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;
)
ieşire:
Concluzie
Structurile în C este un mod foarte interesant de a grupa și grupa toate variabilele și funcțiile de membri definite de utilizator într-o singură entitate. Cu toate acestea, are unele limitări, cum ar fi faptul că nu permite variabilelor de structură și a întregii structuri să conțină tipuri de date încorporate și nici o utilizare a operatorilor. Prin urmare, în viitorul viitor poate că aceste caracteristici pot fi îngrijite.
Articole recomandate
Acesta este un ghid pentru structura cuibărită în C. Aici discutăm modul de lucru în structura cuibărită în C împreună cu diferite exemple și implementarea codului. De asemenea, puteți consulta articolul următor pentru a afla mai multe -
- Top 11 caracteristici ale C ++
- Exemple de tipare în programarea C
- Algoritmul multiplicării matricei de programare C
- Importanța genericilor C #