Sissejuhatus pesastruktuuri C
Igal programmeerimiskeelel on oma viis struktuuride määratlemiseks ja kirjeldamiseks. Nii et pesastatud struktuurid, nagu selle nimetus C-s osutab, määratlevad omamoodi ühe struktuuri teises struktuuris. Mis tahes liikme muutujaid saab määratleda struktuuri sees ja omakorda saab seda struktuuri teisaldada teise struktuuri. Muutujad struktuuri sees võivad olla ükskõik millised nagu tavalised või osutid või midagi muud, ja need võib paigutada struktuuri kõikjale.
Pesastatud struktuurile pääseb juurde kahel viisil:
- Struktuur C-siseses struktuuris osutimuutuja abil.
- Struktuur C-siseses struktuuris tavalise muutuja abil.
Süntaks:
Järgnevalt on toodud pesastatud struktuuri loomise süntaks:
structure tagname_1
(
var_1;
var_2;
var_3;
.
.
.
.
var n;
structure tagname_2
(
var_1;
var_2;
var_3;
.
.
.
var_n;
), mem1
) mem2;
Pesastatud struktuuri kasutamine C-s
Ülaltoodud süntaksist võime järeldada asjaolu, et liikme1 struktuuri sisse pestud mem1-struktuur sisaldab liiget või muutujat, millele tuleb juurde pääseda, ja kõigile saab ligipääsu kasutada pesastatud viisil. (punkti) operaator.
- mem2.mem1.var_1: see viitab muutuja struktuurinimele_1 esimesele liikmele.
- mem2.mem1.var_2: see viitab muutuja struktuuris sildi_nimi teisele liikmele.
Toome veel näiteid, et saada selgust, kuidas süntaks rahuldab pesastatud struktuuri toimimist.
Näited nr 1
struct employee
(
struct man
(
char name (20);
int age;
char dob(10);
) d;
int empid;
char desg(10);
) emp;
Ülaltoodud näites on inimese struktuur määratletud töötajate struktuuris, mis on pesastatud struktuur. Meeste pesastatud struktuuri liikmetele pääseb juurde alloleva süntaksi või vormingu abil.
Nagu antud näites
- töötaja.d . nimi : see räägib mehe nimest töötaja struktuuris.
- töötajad.aeg: see räägib mehe vanusest töötajana.
Oluline on tähele panna ühte asja, nagu seda struktuuri mees töötaja struktuuris ei saa uuesti kasutada, mis tähendab, et seda ei saa kogu koodis uuesti nimetada, kuna see pole ise loodud.
Selle asemel võib selle lahendada:
Oleksime võinud määratleda struktuuri väljaspool ja siis oleksime võinud kuulutada muutuja struktuuri sees, kuhu iganes me sellele koodile juurde pääseme.
Näited nr 2
Struct man
(
char name(20);
int age;
char dob (10);
);
Samuti saab seda struktuuri välisstruktuur uuesti kasutada.
struct employee
(
struct man info;
int id;
char desg (10);
)
Seda tüüpi struktuuri deklaratsiooni kasutamise eeliseks on see, et me võime kuulutada muutuja tüüpi struct man kõikjal kogu programmis.
Märkus . Struktuuri pesitsemine iseenesest pole kunagi lubatud.Vaatame näidet, kuidas struktuuri pesitsemine iseenesest pole lubatud.
struct teacher
(
char name(20);
char address(100);
int age();
struct teacher principal; // totally invalid way to create nested structure.
)
Näited pesas olevatest struktuuridest C-s
Allpool on toodud erinevad näited pesastruktuurist C-s:
Näide nr 1 - Pesastatud struktuuride lähtestamine:
Pesastatud struktuuride lähtestamine on deklareerimise ajal võimalik.
Kood:
struct student
(
struct person info;
int rollno;
float marks(10);
)
struct student student_1 = (
("Anji", 26, 1995),
103,
92
);
Näide
Kood:
#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;
)
Väljund:
Näide nr 2 - Liikmetele ligipääs pesastatud struktuuris osuti abil:
Kood:
#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;
)
Väljund:
Näide # 3 - struktuuriliikme edastamine argumentidena toimimiseks:
Kood:
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");
)
Väljund:
Näide # 4 - struktuuri struktuur tavalise muutuja abil.
Kood:
#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;
)
Väljund:
Näide
Kood:
#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;
)
Väljund:
Järeldus
C-struktuuris on väga huvitav viis grupeerida ja grupeerida kõik kasutaja määratletud liikmemuutujad ja funktsioonid ühte entiteeti. Kuid siiski, sellel on mõned piirangud, kuna see ei võimalda struktuurimuutujatel ja kogu struktuuril sisaldada sisseehitatud andmetüüpe ega kasutada operaatoreid. Seetõttu on nende funktsioonide eest võimalik tulevikus hoolitseda.
Soovitatavad artiklid
See on juhend pesatud struktuurist C-s. Siin käsitleme C-sisestusstruktuuri töötamist koos erinevate näidete ja koodi rakendamisega. Lisateabe saamiseks võite vaadata ka järgmist artiklit -
- C ++ 11 peamist funktsiooni
- C-programmeerimise mustrite näited
- C-programmeerimismaatriksi korrutamise algoritm
- C # geneerikute tähtsus