Wprowadzenie do struktury zagnieżdżonej w C.
Każdy język programowania ma swój własny sposób definiowania i opisywania struktur. Tak więc struktury zagnieżdżone, jak sugeruje jego nazwa w C, są jakby definicją jednej struktury w innej strukturze. Wszelkie zmienne składowe mogą być zdefiniowane wewnątrz struktury, a ta struktura może być dalej przenoszona do innej struktury. Zmienne wewnątrz struktury mogą być dowolne, takie jak normalne, wskaźnikowe lub cokolwiek, i mogą być umieszczone w dowolnym miejscu w strukturze.
Dostęp do struktury zagnieżdżonej można uzyskać na dwa sposoby:
- Struktura wewnątrz struktury w C przy użyciu zmiennej wskaźnika.
- Struktura w strukturze w C przy użyciu zmiennej normalnej.
Składnia:
Poniżej znajduje się składnia do tworzenia zagnieżdżonej 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;
Działanie struktury zagnieżdżonej w C.
Z powyższej składni możemy wywnioskować, że struktura mem1 zagnieżdżona w strukturze member1 będzie zawierała element lub zmienną, do której można uzyskać dostęp, a do każdego można uzyskać dostęp za pomocą zagnieżdżonego. (kropka) operator.
- mem2.mem1.var_1: Odnosi się do pierwszego elementu zmiennej struktury tagname_1.
- mem2.mem1.var_2: Odnosi się do drugiego elementu zmiennej struktury zmienna_2.
Podamy więcej przykładów, aby uzyskać jasność, w jaki sposób składnia spełnia działanie zagnieżdżonej struktury.
Przykłady # 1
struct employee
(
struct man
(
char name (20);
int age;
char dob(10);
) d;
int empid;
char desg(10);
) emp;
W powyższym przykładzie struktura człowieka jest zdefiniowana w strukturze pracownika, która jest strukturą zagnieżdżoną. Do elementów w zagnieżdżonej strukturze, która jest mężczyzną, można uzyskać dostęp za pomocą poniższej składni lub formatu.
Jak w podanym przykładzie
- pracownik.d. nazwa: Mówi o nazwisku mężczyzny w strukturze pracownika.
- worker.d .age: Powie o wieku mężczyzny jako pracownika.
Ważne jest, aby zwrócić uwagę na jedną rzecz, taką jak ta struktura, której człowiek w strukturze pracownika nie może być ponownie użyty, co oznacza, że nie można go wywołać ponownie w dowolnym miejscu w całym kodzie, ponieważ nie jest on generowany samodzielnie.
Zamiast tego obejściem tego problemu może być:
Mogliśmy zdefiniować strukturę na zewnątrz, a następnie zadeklarować zmienną wewnątrz struktury, gdziekolwiek chcemy uzyskać do niej dostęp w całym kodzie.
Przykłady # 2
Struct man
(
char name(20);
int age;
char dob (10);
);
Również ta struktura może być ponownie wykorzystana przez zewnętrzną strukturę.
struct employee
(
struct man info;
int id;
char desg (10);
)
Zaletą korzystania z tego typu deklaracji struktury jest to, że możemy zadeklarować zmienną typu struct man w dowolnym miejscu w programie.
Uwaga: Zagnieżdżanie struktury w sobie nigdy nie jest dozwolone.Zobaczmy przykład, w jaki sposób zagnieżdżanie struktury wewnątrz siebie jest niedozwolone.
struct teacher
(
char name(20);
char address(100);
int age();
struct teacher principal; // totally invalid way to create nested structure.
)
Przykłady struktur zagnieżdżonych w C
Poniżej znajdują się różne przykłady zagnieżdżonej struktury w C:
Przykład 1 - Inicjalizacja struktur zagnieżdżonych:
Inicjalizacja struktur zagnieżdżonych jest możliwa w momencie deklaracji.
Kod:
struct student
(
struct person info;
int rollno;
float marks(10);
)
struct student student_1 = (
("Anji", 26, 1995),
103,
92
);
Przykład
Kod:
#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;
)
Wynik:
Przykład # 2 - Dostęp do elementów wewnątrz struktury zagnieżdżonej za pomocą wskaźników:
Kod:
#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;
)
Wynik:
Przykład # 3 - Przekazywanie elementu struktury jako argumentów funkcji:
Kod:
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");
)
Wynik:
Przykład # 4 - Struktura struktury za pomocą zmiennej normalnej.
Kod:
#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;
)
Wynik:
Przykład
Kod:
#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;
)
Wynik:
Wniosek
Struktury w C to bardzo interesujący sposób na grupowanie i grupowanie wszystkich zdefiniowanych przez użytkownika zmiennych składowych i funkcji w jedną całość. Ale nadal ma pewne ograniczenia, takie jak: nie pozwala, aby zmienne struktury i cała struktura zawierały wbudowane typy danych i nie używały operatorów. Dlatego może już w najbliższej przyszłości można zająć się tymi funkcjami.
Polecane artykuły
Jest to przewodnik po strukturze zagnieżdżonej w C. Tutaj omawiamy pracę w zagnieżdżonej strukturze w C wraz z różnymi przykładami i implementacją kodu. Możesz także spojrzeć na następujący artykuł, aby dowiedzieć się więcej -
- Najważniejsze 11 funkcji C ++
- Przykłady wzorców w programowaniu C.
- Algorytm mnożenia macierzy programowania C
- Znaczenie generycznych C #