Introdução à estrutura aninhada em C
Qualquer linguagem de programação tem sua própria maneira de definir e descrever estruturas. Assim, estruturas aninhadas, como o próprio nome sugere em C, são como definir uma estrutura dentro de outra estrutura. Quaisquer variáveis de membro podem ser definidas dentro de uma estrutura e, por sua vez, essa estrutura pode ser movida para outra estrutura. As variáveis dentro de uma estrutura podem ser algo como normal ou ponteiro ou qualquer coisa e podem ser colocadas em qualquer lugar dentro da estrutura.
Estrutura aninhada pode ser acessada de duas maneiras:
- Estrutura dentro de uma estrutura em C usando a variável ponteiro.
- Estrutura dentro de uma estrutura em C usando uma variável normal.
Sintaxe:
A seguir está a sintaxe para criar uma estrutura aninhada:
structure tagname_1
(
var_1;
var_2;
var_3;
.
.
.
.
var n;
structure tagname_2
(
var_1;
var_2;
var_3;
.
.
.
var_n;
), mem1
) mem2;
Trabalho da estrutura aninhada em C
A partir da sintaxe acima, podemos inferir o fato de que a estrutura mem1 aninhada dentro da estrutura member1 conterá o membro ou a variável a ser acessada e todos poderão ser acessados de maneira aninhada usando. operador (ponto).
- mem2.mem1.var_1: refere-se ao primeiro membro da variável da estrutura tagname_1.
- mem2.mem1.var_2: refere-se ao segundo membro da variável da estrutura tagname_2.
Vamos dar mais exemplos para ter clareza sobre como a sintaxe satisfaz o funcionamento da estrutura aninhada.
Exemplos # 1
struct employee
(
struct man
(
char name (20);
int age;
char dob(10);
) d;
int empid;
char desg(10);
) emp;
No exemplo acima, a estrutura man é definida dentro de uma estrutura de empregado, que é uma estrutura aninhada. Os membros da estrutura aninhada, que é um homem, podem ser acessados usando a sintaxe ou o formato abaixo.
Como no exemplo dado
- employee.d .name: informa sobre o nome do homem dentro da estrutura do funcionário.
- employee.d .age: informa sobre a idade do homem como funcionário.
É importante destacar que algo como essa estrutura na estrutura de funcionários não pode ser reutilizado, o que significa que não pode ser chamado novamente em nenhum lugar do código inteiro, porque não é gerado automaticamente.
Em vez disso, uma solução alternativa para isso pode ser:
Poderíamos ter definido a estrutura fora e, em seguida, poderíamos ter declarado a variável dentro da estrutura onde quer que desejássemos acessá-la através do código.
Exemplos # 2
Struct man
(
char name(20);
int age;
char dob (10);
);
Além disso, essa estrutura pode ser reutilizada pela estrutura externa.
struct employee
(
struct man info;
int id;
char desg (10);
)
A vantagem de usar esse tipo de declaração de estrutura é que podemos declarar uma variável do tipo struct man em qualquer lugar do programa.
Nota: O aninhamento da estrutura em si nunca é permitido.Vamos ver um exemplo de como o aninhamento de estrutura dentro de si não é permitido.
struct teacher
(
char name(20);
char address(100);
int age();
struct teacher principal; // totally invalid way to create nested structure.
)
Exemplos de estruturas aninhadas em C
Abaixo estão os diferentes exemplos de estrutura aninhada em C:
Exemplo # 1 - Inicialização de estruturas aninhadas:
A inicialização de estruturas aninhadas é possível no momento da declaração.
Código:
struct student
(
struct person info;
int rollno;
float marks(10);
)
struct student student_1 = (
("Anji", 26, 1995),
103,
92
);
Exemplo
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;
)
Resultado:
Exemplo # 2 - Acesso de membros dentro da estrutura aninhada usando Ponteiros:
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;
)
Resultado:
Exemplo # 3 - Passando membro da estrutura 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");
)
Resultado:
Exemplo # 4 - Estrutura dentro da estrutura usando uma variável 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;
)
Resultado:
Exemplo
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;
)
Resultado:
Conclusão
Estruturas em C é uma maneira muito interessante de agrupar e agrupar todas as variáveis e funções de membro definidas pelo usuário em uma entidade. Mas, ainda assim, ele tem algumas limitações, pois não permite que variáveis de estrutura e estrutura inteira contenham os tipos de dados incorporados e sem uso de operadores. Portanto, no mero futuro, talvez esses recursos possam ser resolvidos.
Artigos recomendados
Este é um guia para a Estrutura aninhada em C. Aqui discutimos o trabalho em Estrutura aninhada em C, juntamente com diferentes exemplos e implementação de código. Você também pode consultar o seguinte artigo para saber mais -
- Os 11 principais recursos do C ++
- Exemplos de padrões na programação C
- Algoritmo de multiplicação de matrizes de programação C
- Importância dos genéricos de C #