Prerrequisito: Estructuras en C
Una estructura anidada en C es una estructura dentro de una estructura. Una estructura se puede declarar dentro de otra estructura de la misma manera que los miembros de una estructura se declaran dentro de una estructura.
Sintaxis:
estructura nombre_1
{
miembro1;
miembro2;
.
.
miembro;estructura nombre_2
{
miembro_1;
miembro_2;
.
.
miembro_n;
}, var1
} var2;
Se puede acceder al miembro de una estructura anidada usando la siguiente sintaxis:
Nombre de variable de Outer_Structure. Nombre de variable de Nested_Structure. miembro de datos para acceder
Ejemplo:
- Considere que hay dos estructuras Empleado (estructura dependiente) y otra estructura llamada Organización (estructura externa) .
- La estructura Organización tiene miembros de datos como nombre_organización, número_organización.
- La estructura Empleado está anidada dentro de la estructura Organización y tiene miembros de datos como id_empleado, nombre, salario.
Para acceder a los miembros de Organización y Empleado se utilizará la siguiente sintaxis:
org.emp.employee_id;
org.emp.nombre;
org.emp.salario;org.nombre_organización;
org.organization_number;Aquí, org es la variable de estructura de la estructura externa Organización y emp es la variable de estructura de la estructura interna Empleado.
Diferentes formas de anidar la estructura.
La estructura se puede anidar de las siguientes maneras diferentes:
- Por estructura anidada separada
- Por estructura anidada incrustada .
1. Por estructura anidada separada: en este método, se crean las dos estructuras, pero la estructura dependiente (Empleado) debe usarse dentro de la estructura principal (Organización) como miembro. A continuación se muestra el programa C para implementar el enfoque:
C
// C program to implement
// the above approach
#include <stdio.h>
#include <string.h>
// Declaration of the
// dependent structure
struct Employee
{
int employee_id;
char name[20];
int salary;
};
// Declaration of the
// Outer structure
struct Organisation
{
char organisation_name[20];
char org_number[20];
// Dependent structure is used
// as a member inside the main
// structure for implementing
// nested structure
struct Employee emp;
};
// Driver code
int main()
{
// Structure variable
struct Organisation org;
// Print the size of organisation
// structure
printf("The size of structure organisation : %ld\n",
sizeof(org));
org.emp.employee_id = 101;
strcpy(org.emp.name, "Robert");
org.emp.salary = 400000;
strcpy(org.organisation_name,
"GeeksforGeeks");
strcpy(org.org_number, "GFG123768");
// Printing the details
printf("Organisation Name : %s\n",
org.organisation_name);
printf("Organisation Number : %s\n",
org.org_number);
printf("Employee id : %d\n",
org.emp.employee_id);
printf("Employee name : %s\n",
org.emp.name);
printf("Employee Salary : %d\n",
org.emp.salary);
}
Producción:
El tamaño de la organización de la estructura: 68
Nombre de la organización: GeeksforGeeks
Número de organización: GFG123768
Identificación del empleado: 101
Nombre del empleado: Robert
Salario del empleado: 400000
2. Por estructura anidada incrustada: con este método, permite declarar una estructura dentro de una estructura y requiere menos líneas de código.
Caso 1: se producirá un error si la estructura está presente pero falta la variable de estructura.
C
// C program to implement
// the above approach
#include <stdio.h>
// Declaration of the outer
// structure
struct Organisation
{
char organisation_name[20];
char org_number[20];
// Declaration of the employee
// structure
struct Employee
{
int employee_id;
char name[20];
int salary;
// This line will cause error because
// datatype struct Employee is present ,
// but Structure variable is missing.
};
};
// Driver code
int main()
{
// Structure variable of organisation
struct Organisation org;
printf("%ld", sizeof(org));
}
Producción:
Nota:
Cada vez que se crea una estructura anidada incrustada, la declaración de la variable es obligatoria al final de la estructura interna, que actúa como miembro de la estructura externa. Es obligatorio que la variable de estructura se cree al final de la estructura interna.
Caso 2: Cuando la variable de estructura de la estructura interna se declara al final de la estructura interna. A continuación se muestra el programa C para implementar este enfoque:
C
// C program to implement
// the above approach
#include <stdio.h>
#include <string.h>
// Declaration of the main
// structure
struct Organisation
{
char organisation_name[20];
char org_number[20];
// Declaration of the dependent
// structure
struct Employee
{
int employee_id;
char name[20];
int salary;
// variable is created which acts
// as member to Organisation structure.
} emp;
};
// Driver code
int main()
{
struct Organisation org;
// Print the size of organisation
// structure
printf("The size of structure organisation : %ld\n",
sizeof(org));
org.emp.employee_id = 101;
strcpy(org.emp.name, "Robert");
org.emp.salary = 400000;
strcpy(org.organisation_name,
"GeeksforGeeks");
strcpy(org.org_number, "GFG123768");
// Printing the details
printf("Organisation Name : %s\n",
org.organisation_name);
printf("Organisation Number : %s\n",
org.org_number);
printf("Employee id : %d\n",
org.emp.employee_id);
printf("Employee name : %s\n",
org.emp.name);
printf("Employee Salary : %d\n",
org.emp.salary);
}
Producción:
El tamaño de la organización de la estructura: 68
Nombre de la organización: GeeksforGeeks
Número de organización: GFG123768
Identificación del empleado: 101
Nombre del empleado: Robert
Salario del empleado: 400000
Inconveniente de la estructura anidada
Los inconvenientes de las estructuras anidadas son:
- No es posible la existencia independiente: es importante tener en cuenta que la estructura Empleado no existe por sí sola. No se puede declarar una variable de estructura de tipo struct Employee en ningún otro lugar del programa.
- No se puede usar en estructuras de datos múltiples: la estructura anidada no se puede usar en estructuras múltiples debido a la limitación de declarar variables de estructura dentro de la estructura principal. Entonces, la forma más recomendada es usar una estructura separada y se puede usar en múltiples estructuras de datos
Ejemplo de estructura anidada en C
A continuación se muestra otro ejemplo de una estructura anidada en C.
C
// C program to implement
// the nested structure
#include <stdio.h>
#include <string.h>
// Declaration of Outer structure
struct College
{
char college_name[20];
int ranking;
// Declaration of Inner structure
struct Student
{
int student_id;
char name[20];
int roll_no;
// Inner structure variable
} student1;
};
// Driver code
int main()
{
struct College c1 = {"GeeksforGeeks", 7,
{111, "Paul", 278}};
printf("College name : %s\n",
c1.college_name);
printf("Ranking : %d\n",
c1.ranking);
printf("Student id : %d\n",
c1.student1.student_id);
printf("Student name : %s\n",
c1.student1.name);
printf("Roll no : %d\n",
c1.student1.roll_no);
return 0;
}
Producción:
Nombre de la universidad: Ranking GeeksforGeeks : 7
Identificación del estudiante: 111
Nombre del estudiante: Paul
Roll no: 278
Nota:
No se permite anidar la estructura dentro de sí misma.
Ejemplo:
estudiante de estructura
{nombre de char[50];
dirección char[100];
int roll_no;
geek estudiante de estructura; // Inválido
}
Pasar estructura anidada a función
Una estructura anidada se puede pasar a la función de dos maneras:
- Pase la variable de estructura anidada a la vez.
- Pase los miembros de la estructura anidada como argumento a la función.
Analicemos cada una de estas formas en detalle.
1. Pase la variable de estructura anidada a la vez: al igual que otras variables, una variable de estructura anidada también se puede pasar a la función. A continuación se muestra el programa C para implementar este concepto:
C
// C program to implement
// the above approach
#include <stdio.h>
// Declaration of the inner
// structure
struct Employee
{
int employee_id;
char name[20];
int salary;
};
// Declaration of the Outer
// structure
struct Organisation
{
char organisation_name[20];
char org_number[20];
// Nested structure
struct Employee emp;
};
// Function show is expecting
// variable of outer structure
void show(struct Organisation);
// Driver code
int main()
{
struct Organisation org = {"GeeksforGeeks", "GFG111",
{278, "Paul",5000}};
// Organisation structure variable
// is passed to function show
show(org);
}
// Function shoe definition
void show(struct Organisation org )
{
// Printing the details
printf("Printing the Details :\n");
printf("Organisation Name : %s\n",
org.organisation_name);
printf("Organisation Number : %s\n",
org.org_number);
printf("Employee id : %d\n",
org.emp.employee_id);
printf("Employee name : %s\n",
org.emp.name);
printf("Employee Salary : %d\n",
org.emp.salary);
}
Producción:
Impresión de los detalles:
Nombre de la organización: GeeksforGeeks
Número de la organización: GFG111
Identificación del empleado: 278
Nombre del empleado: Paul
Salario del empleado: 5000
2. Pase los miembros de la estructura anidados como argumentos a la función: Considere el siguiente ejemplo para pasar el miembro de la estructura del empleado a una función display() que se usa para mostrar los detalles de un empleado.
C
// C program to implement
// the above approach
#include <stdio.h>
// Declaration of the inner
// structure
struct Employee
{
int employee_id;
char name[20];
int salary;
};
// Declaration of the Outer
// structure
struct Organisation
{
char organisation_name[20];
char org_number[20];
// Nested structure
struct Employee emp;
};
// Function show is expecting
// members of both structures
void show(char organisation_name[],
char org_number[],
int employee_id,
char name[], int salary);
// Driver code
int main()
{
struct Organisation org = {"GeeksforGeeks", "GFG111",
{278, "Paul",5000}};
// Data members of both the structures
// are passed to the function show
show(org.organisation_name, org.org_number,
org.emp.employee_id, org.emp.name,
org.emp.salary);
}
// Function show definition
void show(char organisation_name[],
char org_number[],
int employee_id,
char name[], int salary)
{
// Printing the details
printf("Printing the Details :\n");
printf("Organisation Name : %s\n",
organisation_name);
printf("Organisation Number : %s\n",
org_number);
printf("Employee id : %d\n",
employee_id);
printf("Employee name : %s\n",
name);
printf("Employee Salary : %d\n",
salary);
}
Producción:
Impresión de los detalles:
Nombre de la organización: GeeksforGeeks
Número de la organización: GFG111
Identificación del empleado: 278
Nombre del empleado: Paul
Salario del empleado: 5000
Acceso a la estructura anidada
Se puede acceder a la estructura anidada de dos maneras:
- Usando la variable Normal.
- Usando la variable Puntero.
Analicemos cada uno de estos métodos en detalle.
1. Uso de la variable normal: las variables de estructura externa e interna se declaran como variables normales y se accede a los miembros de datos de la estructura externa usando un solo punto (.) y se accede a los miembros de datos de la estructura interna usando los dos puntos. A continuación se muestra el programa C para implementar este concepto:
C
// C program to implement
// the above approach
#include <stdio.h>
#include <string.h>
// Declaration of inner structure
struct college_details
{
int college_id;
char college_name[50];
};
// Declaration of Outer structure
struct student_detail
{
int student_id;
char student_name[20];
float cgpa;
// Inner structure variable
struct college_details clg;
} stu;
// Driver code
int main()
{
struct student_detail stu = {12, "Kathy", 7.8,
{14567, "GeeksforGeeks"}};
// Printing the details
printf("College ID : %d \n", stu.clg.college_id);
printf("College Name : %s \n", stu.clg.college_name);
printf("Student ID : %d \n", stu.student_id);
printf("Student Name : %s \n", stu.student_name);
printf("Student CGPA : %f \n", stu.cgpa);
return 0;
}
Producción:
ID de la universidad: 14567
Nombre de la universidad: GeeksforGeeks
ID del estudiante: 12
Nombre del estudiante: Kathy
Student CGPA: 7.800000
2. Uso de la variable de puntero: se declara una variable normal y una variable de puntero de la estructura para explicar la diferencia entre las dos. En el caso de la variable de puntero, se utilizará una combinación de punto (.) y flecha (->) para acceder a los miembros de datos. A continuación se muestra el programa C para implementar el enfoque anterior:
C
// C program to implement
// the above approach
#include <stdio.h>
#include <string.h>
// Declaration of inner structure
struct college_details
{
int college_id;
char college_name[50];
};
// Declaration of Outer structure
struct student_detail
{
int student_id;
char student_name[20];
float cgpa;
// Inner structure variable
struct college_details clg;
} stu, *stu_ptr;
// Driver code
int main()
{
struct student_detail stu = {12, "Kathy", 7.8,
{14567, "GeeksforGeeks"}};
stu_ptr = &stu;
// Printing the details
printf("College ID : %d \n", stu_ptr->clg.college_id);
printf("College Name : %s \n", stu_ptr->clg.college_name);
printf("Student ID : %d \n", stu_ptr->student_id);
printf("Student Name : %s \n", stu_ptr->student_name);
printf("Student CGPA : %f \n", stu_ptr->cgpa);
return 0;
}
Producción:
ID de la universidad: 14567
Nombre de la universidad: GeeksforGeeks
ID del estudiante: 12
Nombre del estudiante: Kathy
Student CGPA: 7.800000
Una estructura anidada permitirá la creación de tipos de datos complejos según los requisitos del programa.
Publicación traducida automáticamente
Artículo escrito por sathiyamoorthics19 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA