Beágyazott szerkezet C - Beágyazott szerkezet működése C-ben példákkal

• Bevezetés a beágyazott szerkezetbe C

Bevezetés a beágyazott szerkezetbe C

Bármely programozási nyelvnek megvan a maga módja a struktúrák meghatározására és leírására. Tehát a beágyazott struktúrák, amint a neve C-ben sugallja, egyfajta meghatározza az egyik szerkezetet egy másik struktúrán belül. Bármely tagváltozó meghatározható egy struktúrán belül, és ez viszont tovább mozgatható egy másik struktúrába. A struktúrán belüli változók bármi lehet, például normál vagy mutató, vagy bármi más, és bárhol elhelyezhetők a szerkezeten belül.

A beágyazott szerkezet kétféle módon érhető el:

1. Szerkezet belső struktúrája C-ben a mutató változó segítségével.
2. Szerkezet egy struktúrában belül C-ben egy normál változó segítségével.

Szintaxis:

Az alábbiakban bemutatjuk a beágyazott struktúra létrehozásának szintaxisát:

structure tagname_1
(
var_1;
var_2;
var_3;
.
.
.
.
var n;
structure tagname_2
(
var_1;
var_2;
var_3;
.
.
.
var_n;
), mem1
) mem2;

Beágyazott szerkezet működése C-ben

A fenti szintaxisból levonhatjuk azt a tényt, hogy a mem1 szerkezetbe beágyazott tag1 struktúra tartalmazza a hozzáférhető tagot vagy változót, és mindenki hozzáférhető beágyazott módon a használatával. (pont) operátor.

• mem2.mem1.var_1: Ez a tagname_1 szerkezeti változó első tagjára vonatkozik.
• mem2.mem1.var_2: Ez a tagname_2 szerkezeti változó második tagjára vonatkozik.

További példákat veszünk annak tisztázására, hogy a szintaxis miként felel meg a beágyazott struktúra működésének.

1. példa

struct employee
(
struct man
(
char name (20);
int age;
char dob(10);
) d;
int empid;
char desg(10);
) emp;

A fenti példában az ember szerkezetét egy alkalmazott szerkezetben definiáljuk, amely beágyazott struktúra. A beágyazott struktúrában lévő tagok, azaz az emberek az alábbi szintaxis vagy formátum segítségével érhetők el.

Mint az adott példában

• alkalmazott.d .név: A munkavállalói struktúrában lévő ember nevéről szól.
• töötaja.d .: kép: Ez az ember a munkavállaló életkoráról szól.

Fontos, hogy észrevegyünk egy olyan dolgot, mint amilyen ez a struktúra az ember a munkavállalói struktúrában nem használható fel újra, ami azt jelenti, hogy a teljes kódban sehol nem hívható meg, mert nem az ön által generált.

Ehelyett a megoldás a következő lehet:

Meghatározhattuk volna a struktúrát kívülről, és akkor deklarálhatjuk a változót a szerkezeten belül, bárhová akarjuk elérni.

2. példa

Struct man
(
char name(20);
int age;
char dob (10);
);

Ezt a szerkezetet a külső szerkezet is felhasználhatja.

struct employee
(
struct man info;
int id;
char desg (10);
)

Az ilyen típusú struktúra-deklaráció alkalmazásának előnye az, hogy a program egész területén bárhol deklarálhatunk egy típusú struct típusú változót.

Megjegyzés: A szerkezet fészkelése önmagában soha nem engedélyezett.

Nézzük meg egy példát arra, hogy a szerkezet fészkelése önmagában nem megengedett.

struct teacher
(
char name(20);
char address(100);
int age();
struct teacher principal; // totally invalid way to create nested structure.
)


Példák beágyazott struktúrákra a C-ben

Az alábbiakban bemutatjuk a C beágyazott szerkezet különböző példáit:

1. példa - Beágyazott struktúrák inicializálása:

A beágyazott struktúrák inicializálása a deklaráció idején lehetséges.

Kód:

struct student
(
struct person info;
int rollno;
float marks(10);
)
struct student student_1 = (
("Anji", 26, 1995),
103,
92
);

Példa

Kód:

#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;
)

Kimenet:

2. példa - Tagok elérése a beágyazott struktúrában a mutatók segítségével:

Kód:

#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;
)

Kimenet:

3. példa - A szerkezeti tag átadása argumentumként a működéshez:

Kód:

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");
)

Kimenet:

4. példa - Szerkezet belső struktúrája egy normál változó segítségével.

Kód:

#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;
)

Kimenet:

Példa

Kód:

#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;
)

Kimenet:

Megjegyzés: Bár jó átadni a szerkezeti változókat argumentumként, mert lehetővé teszi, hogy a struktúra összes tagját működésbe bocsátjuk, de ez még nem szokásos módszer erre.

Következtetés

A C struktúrák nagyon érdekes módja annak, hogy az összes felhasználó által definiált tagváltozót és funkciót egy entitásba csoportosítsuk. Ennek ellenére van néhány korlátozása, mivel nem engedi, hogy a szerkezeti változók és a teljes struktúra tartalmazzák a beépített adattípusokat, és ne használják az operátorokat. Ezért valószínűleg a jövőben ezeket a funkciókat már a jövőben is meg lehet gondolni.

Ajánlott cikkek

Ez egy útmutató a C. beágyazott struktúrához. Itt tárgyaljuk a C beágyazott struktúrában végzett munkát, különféle példákkal és a kód megvalósításával együtt. A következő cikkben további információkat is megnézhet -

1. A C ++ 11 legnépszerűbb tulajdonsága
2. Példák mintákra a C programozásban
3. C programozási mátrix szorzás algoritmusa
4. A C # generikus termékek fontossága