Introducción a la estructura anidada en C
Cualquier lenguaje de programación tiene su propia forma de definir y describir estructuras. Entonces, las estructuras anidadas como su nombre sugiere en C es como definir una estructura dentro de otra estructura. Cualquier variable miembro se puede definir dentro de una estructura y, a su vez, esa estructura se puede mover a otra estructura. Las variables dentro de una estructura pueden ser normales, puntero o cualquier cosa, y pueden colocarse en cualquier lugar dentro de la estructura.
Se puede acceder a la estructura anidada de dos maneras:
- Estructura dentro de una estructura en C usando la variable puntero.
- Estructura dentro de una estructura en C usando una variable normal.
Sintaxis:
La siguiente es la sintaxis para crear una estructura anidada:
structure tagname_1
(
var_1;
var_2;
var_3;
.
.
.
.
var n;
structure tagname_2
(
var_1;
var_2;
var_3;
.
.
.
var_n;
), mem1
) mem2;
Trabajo de estructura anidada en C
A partir de la sintaxis anterior, podemos inferir el hecho de que la estructura mem1 anidada dentro de la estructura member1 contendrá el miembro o la variable a la que se accederá y se puede acceder a todos de manera anidada mediante el uso. (punto) operador.
- mem2.mem1.var_1: se refiere al primer miembro de la variable de la estructura tagname_1.
- mem2.mem1.var_2: se refiere al segundo miembro de la variable de la estructura tagname_2.
Tomaremos más ejemplos para obtener claridad sobre cómo la sintaxis satisface el funcionamiento de la estructura anidada.
Ejemplos # 1
struct employee
(
struct man
(
char name (20);
int age;
char dob(10);
) d;
int empid;
char desg(10);
) emp;
En el ejemplo anterior, la estructura de hombre se define dentro de una estructura de empleado que es una estructura anidada. Se puede acceder a los miembros dentro de la estructura anidada, que es un hombre, utilizando la sintaxis o el formato a continuación.
Como en el ejemplo dado
- employee.d .name: Informa sobre el nombre del hombre dentro de la estructura del empleado.
- employee.d .age: Se informará sobre la edad del hombre como empleado.
Es importante tener en cuenta una cosa como esta estructura, el hombre dentro de la estructura del empleado no se puede reutilizar, lo que significa que no se puede volver a llamar a ninguna parte del código porque no se genera automáticamente.
En cambio, una solución para esto puede ser:
Podríamos haber definido la estructura exterior y luego haber declarado la variable dentro de la estructura donde queramos acceder a través del código.
Ejemplos # 2
Struct man
(
char name(20);
int age;
char dob (10);
);
Además, esta estructura puede ser reutilizada por la estructura externa.
struct employee
(
struct man info;
int id;
char desg (10);
)
La ventaja de usar este tipo de declaración de estructura es que podemos declarar una variable de tipo struct man en cualquier parte del programa.
Nota: el anidamiento de la estructura dentro de sí mismo nunca está permitido.Veamos un ejemplo de cómo no está permitido anidar la estructura dentro de sí mismo.
struct teacher
(
char name(20);
char address(100);
int age();
struct teacher principal; // totally invalid way to create nested structure.
)
Ejemplos de estructuras anidadas en C
A continuación se muestran los diferentes ejemplos de estructura anidada en C:
Ejemplo # 1 - Inicialización de estructuras anidadas:
La inicialización de estructuras anidadas es posible en el momento de la declaración.
Código:
struct student
(
struct person info;
int rollno;
float marks(10);
)
struct student student_1 = (
("Anji", 26, 1995),
103,
92
);
Ejemplo
Código:
#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;
)
Salida:
Ejemplo # 2 - Acceso de miembros dentro de la estructura anidada usando Punteros:
Código:
#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;
)
Salida:
Ejemplo # 3 - Pasando miembro de estructura como argumentos para funcionar:
Código:
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");
)
Salida:
Ejemplo # 4 - Estructura dentro de la estructura usando una variable normal.
Código:
#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;
)
Salida:
Ejemplo
Código:
#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;
)
Salida:
Conclusión
Las estructuras en C son una forma muy interesante de agrupar y agrupar todas las variables y funciones miembro definidas por el usuario en una sola entidad. Pero aún así, tiene algunas limitaciones, ya que no permite que las variables de estructura y toda la estructura contengan los tipos de datos integrados y no utilicen operadores. Por lo tanto, en el futuro, tal vez estas características puedan ser atendidas.
Artículos recomendados
Esta es una guía de la Estructura anidada en C. Aquí discutimos el trabajo en Estructura anidada en C junto con diferentes ejemplos e implementación de código. También puede consultar el siguiente artículo para obtener más información:
- Las 11 características principales de C ++
- Ejemplos de patrones en la programación en C
- Algoritmo de Multiplicación de Matriz de Programación C
- Importancia de los genéricos de C #