Introduction à la structure imbriquée en C
Tout langage de programmation a sa propre façon de définir et de décrire les structures. Ainsi, les structures imbriquées comme son nom l'indique en C sont en quelque sorte la définition d'une structure à l'intérieur d'une autre structure. Toutes les variables membres peuvent être définies à l'intérieur d'une structure et à son tour, cette structure peut en outre être déplacée dans une autre structure. Les variables à l'intérieur d'une structure peuvent être quelque chose comme normal ou pointeur ou quoi que ce soit et peuvent être placées n'importe où dans la structure.
La structure imbriquée est accessible de deux manières:
- Structure à l'intérieur d'une structure en C à l'aide de la variable pointeur.
- Structure à l'intérieur d'une structure en C à l'aide d'une variable normale.
Syntaxe:
Voici la syntaxe pour créer une structure imbriquée:
structure tagname_1
(
var_1;
var_2;
var_3;
.
.
.
.
var n;
structure tagname_2
(
var_1;
var_2;
var_3;
.
.
.
var_n;
), mem1
) mem2;
Fonctionnement de la structure imbriquée en C
De la syntaxe ci-dessus, nous pouvons déduire le fait que la structure mem1 imbriquée à l'intérieur de la structure member1 contiendra le membre ou la variable à accéder et que tout le monde peut être accédé de manière imbriquée à l'aide de. (point).
- mem2.mem1.var_1: il s'agit du premier membre de la variable de la structure tagname_1.
- mem2.mem1.var_2: Cela fait référence au deuxième membre de la variable de la structure tagname_2.
Nous prendrons plus d'exemples pour clarifier comment la syntaxe satisfait le fonctionnement de la structure imbriquée.
Exemples # 1
struct employee
(
struct man
(
char name (20);
int age;
char dob(10);
) d;
int empid;
char desg(10);
) emp;
Dans l'exemple ci-dessus, la structure humaine est définie à l'intérieur d'une structure d'employé qui est une structure imbriquée. Les membres de la structure imbriquée qui est un homme sont accessibles en utilisant la syntaxe ou le format ci-dessous.
Comme dans l'exemple donné
- employee.d .name: Il indique le nom de l'homme à l'intérieur de la structure des employés.
- employee.d .age: Il indiquera l'âge de l'homme en tant qu'employé.
Il est important de noter qu'une chose comme cette structure, l'homme dans la structure des employés ne peut pas être réutilisée, ce qui signifie qu'elle ne peut pas être appelée à nouveau n'importe où dans le code entier car elle n'est pas auto-générée.
Au lieu de cela, une solution de contournement pour cela peut être:
Nous aurions pu définir la structure à l'extérieur, puis nous aurions pu déclarer la variable à l'intérieur de la structure où nous voulons y accéder tout au long du code.
Exemples # 2
Struct man
(
char name(20);
int age;
char dob (10);
);
De plus, cette structure peut être réutilisée par la structure extérieure.
struct employee
(
struct man info;
int id;
char desg (10);
)
L'avantage d'utiliser ce type de déclaration de structure est que nous pouvons déclarer une variable de type struct man n'importe où dans le programme.
Remarque: l' imbrication de la structure en elle-même n'est jamais autorisée.Voyons un exemple de l'imbrication de la structure en elle-même.
struct teacher
(
char name(20);
char address(100);
int age();
struct teacher principal; // totally invalid way to create nested structure.
)
Exemples de structures imbriquées en C
Voici les différents exemples de structure imbriquée en C:
Exemple # 1 - Initialisation de structures imbriquées:
L'initialisation des structures imbriquées est possible au moment de la déclaration.
Code:
struct student
(
struct person info;
int rollno;
float marks(10);
)
struct student student_1 = (
("Anji", 26, 1995),
103,
92
);
Exemple
Code:
#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;
)
Production:
Exemple # 2 - Accès des membres à l'intérieur d'une structure imbriquée à l'aide de pointeurs:
Code:
#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;
)
Production:
Exemple # 3 - Passer un membre de la structure comme arguments pour fonctionner:
Code:
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");
)
Production:
Exemple # 4 - Structure à l'intérieur de la structure en utilisant une variable normale.
Code:
#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;
)
Production:
Exemple
Code:
#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;
)
Production:
Conclusion
Les structures en C sont un moyen très intéressant de regrouper et de regrouper toutes les variables et fonctions membres définies par l'utilisateur en une seule entité. Mais tout de même, il a quelques limitations car il ne permet pas aux variables de structure et à la structure entière de contenir les types de données intégrés et aucune utilisation d'opérateurs. Par conséquent, dans un futur proche, ces fonctionnalités peuvent peut-être être prises en charge.
Articles recommandés
Ceci est un guide de la structure imbriquée en C. Ici, nous discutons du fonctionnement de la structure imbriquée en C avec différents exemples et l'implémentation de code. Vous pouvez également consulter l'article suivant pour en savoir plus -
- Top 11 des fonctionnalités de C ++
- Exemples de modèles dans la programmation C
- Algorithme de multiplication de matrice de programmation C
- Importance des génériques C #