Johdatus sisäkkäiseen rakenteeseen C: ssä
Jokaisella ohjelmointikielellä on oma tapa määritellä ja kuvata rakenteita. Joten sisäkkäiset rakenteet, kuten nimensä osoittaa C: ssä, määrittelee erään rakenteen toisen rakenteen sisällä. Mikä tahansa jäsenmuuttuja voidaan määritellä rakenteen sisällä ja vuorostaan, että rakenne voidaan edelleen siirtää toiseen rakenteeseen. Rakenteen sisällä olevat muuttujat voivat olla mitä tahansa normaalia tai osoitinta tai mitä tahansa, ja ne voidaan sijoittaa mihin tahansa rakenteen sisällä.
Sisäiseen rakenteeseen pääsee kahdella tavalla:
- Rakenne rakenteen sisällä C: ssä osoittimen muuttujan avulla.
- Rakenne rakenteen sisällä C: ssä normaalia muuttujaa käyttämällä.
Syntaksi:
Seuraava on syntaksi sisäkkäisen rakenteen luomiseksi:
structure tagname_1
(
var_1;
var_2;
var_3;
.
.
.
.
var n;
structure tagname_2
(
var_1;
var_2;
var_3;
.
.
.
var_n;
), mem1
) mem2;
Sisäkkäisen rakenteen toiminta C: ssä
Yllä olevasta syntaksista voimme päätellä tosiasian, että jäsen1-rakenteen sisäkkäin sisäkkäin mem1-rakenne sisältää jäsenen tai muuttujan, jota on tarkoitus käyttää, ja jokaiselle pääsee käsiksi sisäkkäisellä tavalla käyttämällä. (piste) operaattori.
- mem2.mem1.var_1: Tämä viittaa rakennetunnisteen_1 muuttujan ensimmäiseen jäseneen.
- mem2.mem1.var_2: Tämä viittaa rakenteen tunnusnimen_2 muuttujan toiseen jäseneen.
Otamme lisää esimerkkejä saadaksesi selkeyttä siitä, kuinka syntaksi tyydyttää sisäkkäisen rakenteen toiminnan.
Esimerkit # 1
struct employee
(
struct man
(
char name (20);
int age;
char dob(10);
) d;
int empid;
char desg(10);
) emp;
Yllä olevassa esimerkissä ihmisen rakenne määritellään työntekijärakenteen sisällä, joka on sisäkkäinen rakenne. Miesten sisäkkäisen rakenteen jäseniä voidaan käyttää alla olevan syntaksin tai muodon avulla.
Kuten annetussa esimerkissä
- työntekijän.d . nimi : Se kertoo miehen nimestä työntekijän rakenteessa.
- työntekijä.d .age: Se kertoo miehen iästä työntekijänä.
Tärkeää on huomata yksi asia, kuten tämän rakenteen mies, työntekijärakenteessa ei voida käyttää uudelleen, mikä tarkoittaa, että sitä ei voida kutsua uudelleen mihinkään koko koodiin, koska se ei ole itse luoma.
Sen sijaan kiertotapa tähän voi olla:
Voisimme määritellä rakenteen ulkopuolella ja sitten olisimme voineet julistaa muuttujan rakenteen sisällä missä haluamme käyttää sitä koko koodissa.
Esimerkit 2
Struct man
(
char name(20);
int age;
char dob (10);
);
Ulkoinen rakenne voi myös käyttää tätä rakennetta uudelleen.
struct employee
(
struct man info;
int id;
char desg (10);
)
Tämän tyyppisen rakenneilmoituksen käytön etuna on, että voimme julistaa tyypin struct man tyypin muuttujan kaikkialla ohjelmassa.
Huomaa: Rakenteen pesiminen itsessään ei ole koskaan sallittua.Katsotaan esimerkki siitä, kuinka rakenteen pesiminen itsessään ei ole sallittua.
struct teacher
(
char name(20);
char address(100);
int age();
struct teacher principal; // totally invalid way to create nested structure.
)
Esimerkkejä sisäkkäisistä rakenteista C: ssä
Alla on erilaisia esimerkkejä sisäkkäisestä rakenteesta C: ssä:
Esimerkki 1 - Sisäkkäisten rakenteiden alustaminen:
Sisäkkäisten rakenteiden alustaminen on mahdollista ilmoituksen tekohetkellä.
Koodi:
struct student
(
struct person info;
int rollno;
float marks(10);
)
struct student student_1 = (
("Anji", 26, 1995),
103,
92
);
esimerkki
Koodi:
#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;
)
lähtö:
Esimerkki 2 - Jäsenten pääsy sisäkkäiseen rakenteeseen osoittimien avulla:
Koodi:
#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;
)
lähtö:
Esimerkki 3 - Rakennejäsenen siirtäminen argumentteiksi toimimiseksi:
Koodi:
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");
)
lähtö:
Esimerkki 4 - rakenne rakenteen sisällä normaalia muuttujaa käyttämällä.
Koodi:
#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;
)
lähtö:
esimerkki
Koodi:
#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;
)
lähtö:
johtopäätös
C: n rakenteet ovat erittäin mielenkiintoinen tapa ryhmitellä ja ryhmitellä kaikki käyttäjän määrittelemät jäsenmuuttujat ja toiminnot yhdeksi kokonaisuudeksi. Mutta silti sillä on joitain rajoituksia, koska se ei salli rakennemuuttujien ja koko rakenteen sisältävän sisäänrakennettuja tietotyyppejä eikä operaattoreiden käyttöä. Siksi ehkä nämä ominaisuudet voidaan hoitaa pelkästään tulevaisuudessa.
Suositellut artikkelit
Tämä on opas sisäkkäiseen rakenteeseen C. Tässä keskustellaan C: n sisäisen rakenteen työskentelystä erilaisilla esimerkeillä ja koodin toteutuksella. Voit myös tarkastella seuraavaa artikkelia saadaksesi lisätietoja -
- C ++: n 11 tärkeintä ominaisuutta
- Esimerkkejä malleista C-ohjelmoinnissa
- C-ohjelmointimatriisin kertolaskun algoritmi
- C # geneeristen tuotteiden merkitys