Úvod do vnořené struktury v C
Jakýkoli programovací jazyk má svůj vlastní způsob definování a popisu struktur. Takže vnořené struktury, jak název napovídá v C, jsou druhem definice jedné struktury uvnitř jiné struktury. Jakákoli členská proměnná může být definována uvnitř struktury a zase může být tato struktura dále přesunuta do jiné struktury. Proměnné uvnitř struktury mohou být cokoli jako normální nebo ukazatel nebo cokoli a mohou být umístěny kdekoli v rámci struktury.
Vnořená struktura je přístupná dvěma způsoby:
- Struktura uvnitř struktury v C pomocí proměnné ukazatele.
- Struktura uvnitř struktury v C pomocí normální proměnné.
Syntax:
Následuje syntaxe pro vytvoření vnořené struktury:
structure tagname_1
(
var_1;
var_2;
var_3;
.
.
.
.
var n;
structure tagname_2
(
var_1;
var_2;
var_3;
.
.
.
var_n;
), mem1
) mem2;
Práce vnořené struktury v C
Z výše uvedené syntaxe můžeme odvodit skutečnost, že struktura mem1 vnořená uvnitř struktury member1 bude obsahovat člena nebo proměnnou, ke které se má přistupovat, a ke všem lze přistupovat vnořeným způsobem pomocí. (dot) operátor.
- mem2.mem1.var_1: Jedná se o prvního člena proměnné struktury název_skupiny.
- mem2.mem1.var_2: Toto se týká druhého člena proměnné struktury název_skupiny_2.
Uděláme více příkladů, abychom objasnili, jak syntaxe vyhovuje fungování vnořené struktury.
Příklady # 1
struct employee
(
struct man
(
char name (20);
int age;
char dob(10);
) d;
int empid;
char desg(10);
) emp;
Ve výše uvedeném příkladu je struktura člověka definována uvnitř struktury zaměstnance, která je vnořenou strukturou. K členům uvnitř vnořené struktury, která je člověkem, lze přistupovat pomocí níže uvedené syntaxe nebo formátu.
Jako v daném příkladu
- employee.d .name: Vypovídá o jménu muže uvnitř struktury zaměstnance.
- employee.d .age: Vypovídá o věku muže jako zaměstnance.
Je důležité si uvědomit jednu věc, jako je tato struktura, člověk ve struktuře zaměstnanců nemůže být znovu použit, což znamená, že jej nelze znovu zavolat nikde v celém kódu, protože není vytvořen sám.
Místo toho může být toto řešení:
Mohli jsme definovat strukturu venku a pak jsme mohli deklarovat proměnnou uvnitř struktury kdekoli chceme, aby k ní byl přístup v celém kódu.
Příklady # 2
Struct man
(
char name(20);
int age;
char dob (10);
);
Také tato struktura může být znovu použita vnější strukturou.
struct employee
(
struct man info;
int id;
char desg (10);
)
Výhodou použití tohoto typu deklarace struktury je to, že můžeme deklarovat proměnnou typu struct man kdekoli v celém programu.
Poznámka: Vnoření struktury v sobě není nikdy povoleno.Podívejme se na příklad, jak není vnoření struktury uvnitř sebe povoleno.
struct teacher
(
char name(20);
char address(100);
int age();
struct teacher principal; // totally invalid way to create nested structure.
)
Příklady vnořených struktur v C
Níže jsou uvedeny různé příklady vnořené struktury v jazyce C:
Příklad č. 1 - Inicializace vnořených struktur:
Inicializace vnořených struktur je možná v době deklarace.
Kód:
struct student
(
struct person info;
int rollno;
float marks(10);
)
struct student student_1 = (
("Anji", 26, 1995),
103,
92
);
Příklad
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;
)
Výstup:
Příklad č. 2 - Přístup členů do vnořené struktury pomocí ukazatelů:
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;
)
Výstup:
Příklad č. 3 - Předávání členů struktury jako argumentů k fungování:
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");
)
Výstup:
Příklad č. 4 - Struktura vnitřní struktury pomocí normální proměnné.
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;
)
Výstup:
Příklad
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;
)
Výstup:
Závěr
Struktury v C je velmi zajímavý způsob, jak seskupit a seskupit všechny uživatelem definované členské proměnné a funkce do jedné entity. Přesto má určitá omezení, protože neumožňuje, aby proměnné struktury a celá struktura obsahovaly vestavěné datové typy a žádné použití operátorů. Proto je v budoucnu možná o tyto funkce postaráno.
Doporučené články
Toto je průvodce vnořenou strukturou v C. Zde diskutujeme práci v vnořené struktuře v C spolu s různými příklady a implementací kódu. Další informace naleznete také v následujícím článku -
- Prvních 11 funkcí C ++
- Příklady vzorců v programování C
- Algoritmus násobení matic programování v jazyce C
- Význam C # generik