Apprendre C/C++ Étape par Étape - Page 10

10. Étape par Étape C/C++ — Programmation C - Structure

Structures

| | 1. Introduction

2. Déclaration de Structure
3. Définir une Variable de Structure
4. Initialiser une Variable de Structure
5. Affectation directe de structures
6. Calcul de la taille de la Structure
7. Structures Imbriquées
8. Tableau de Structures
9. Tableaux dans les Structures
10. Passer des Structures à une Fonction
11. Retourner des Structures depuis des Fonctions
12. Pointeur vers une structure
13. Structure contenant des Pointeurs
14. Structures Auto-référentielles |

1. Introduction

| | int a[4] = { 3, 4, 5, 6 };                / Expression valide /
int a[4] = { 3, 4.23, 5, 6 };                / Expression invalide /
int a[4] = { 3, “Siglov”, 5,3}                / Expression invalide / |

Pourquoi les deux dernières expressions sont-elles invalides ? Un tableau peut stocker des valeurs du même type. Ils doivent être du même type. Alors qu’une structure peut contenir plus d’un type de données selon sa définition.

| | • Un groupe d’une ou plusieurs variables de différents types de données organisées ensemble sous un seul nom est appelé une structure ou
• Une collection de types de données hétérogènes (dissimiles) regroupés sous un seul nom est appelée une structure ou
• Une structure est une collection de variables simples. La variable dans une structure peut être de différents types. Les éléments de données dans une structure sont appelés les membres des structures. |

2. Déclaration d’une structure

Lorsqu’une structure est définie, l’ensemble du groupe est référencé par le nom de la structure. Les composants individuels présents dans la structure sont appelés membres de la structure et ceux-ci peuvent être accédés et traités séparément.

| | |

Ex :

| | struct date
{
int day;
int month;
int year;
}; | struct student
{
int sno;
char name[20];
int marks;
float avg;
}; |

3. Définir une Variable de Structure

Définir une variable de structure est la même chose que de définir un type de données intégré tel que int.

| | int a;                             /  valide /
date d;                          / valide (Mais seulement en C++) /
struct date d;                 / valide à la fois en C et C++  / |

4. Initialiser une Variable de Structure

Les membres de la structure peuvent être initialisés comme d’autres variables. Cela peut être fait au moment de la déclaration ou au moment de la conception.

| 1. Initialisation à la Déclaration :
struct ddate
{
int day;
int month;
int year;
} d = { 27, 10, 2000 }; | 2. Initialisation à la Définition :
struct ddate d = { 27, 10, 2000 }; | | 1. Initialisation au moment de la conception : ddate d;
d.day = 27;
d.month = 10;
d.year = 2000; | 4. Initialisation au moment de l’exécution :
scanf(“%d%d%d”, &d.day, &d.month, &d.year); |

Ex :

| | / Écrire un programme pour accepter et imprimer les détails d’un employé /
/ 73_struct.c /
#include
struct emp
{
int eno;
char name[20];
float sal;
};
int main()
{
struct emp e;

printf(“Entrez le numéro de l’employé    :”); scanf(“%d”, &e.eno);
printf(“Entrez le nom de l’employé       :”); scanf(“%s”, e.name);
printf(“Entrez le salaire de l’employé      :”); scanf(“%d”, &e.sal);
printf(“\n\nLes détails de l’employé sont les suivants…. “);
printf(“%d    %s      %d”, e.eno, e.name, e.sal);
return 0;
} |

5. Affectation directe de structures

L’affectation directe de plus d’une variable est rendue possible en utilisant des structures.

| | struct emp a, b = {1001, “Vimal”, 6700.00 };
a = b; / Valide /
printf(“%d %s %d” , a.eno, a.name, a.sal ); | | | Sortie :
1001 Vimal 6700.00 |

6. Calcul de la taille de la structure

Chaque type de données en C/C++ a une taille spécifiée, c’est-à-dire que int a une taille de 2 octets, float a une taille de 4 octets, et ainsi de suite. Voici comment trouver la taille d’une variable de structure.

sizeof:- Cette fonction est utilisée pour trouver la taille d’une variable donnée.

| | printf(“%d”, sizeof(int));                           / 2  /
printf(“%d”, sizeof(float));                       / 4  /
printf(“%d”, sizeof(struct emp));              / Affiche la taille de la structure emp / |

7. Structures Imbriquées

Une structure à l’intérieur de structures est connue sous le nom de structures imbriquées. Pour accéder aux membres de la structure imbriquée, nous devons appliquer l’opérateur point deux fois lors de l’appel des membres de la structure.

Ex :

| | / programme pour démontrer la structure imbriquée avec la structure employé /
/ 74_nested.c /
#include
struct emp
{
int eno;
char name[10];
float sal;
struct                                                    / Structure Imbriquée  /
{
street char[10];
city char[10];
} addr;
};
int main()
{
struct emp e;
printf(“Entrez emp_no, emp_name, emp_sal, street, city “);
scanf(“%d%s%d%s%s”, &e.eno, e.name, &e.sal, e.addr.street, e.addr.city );
printf(“\n\nLes détails de l’employé sont les suivants   …. “);
printf(“%d%s%d%s%s”, e.eno, e.name, e.sal, e.addr.street, e.addr.city );
return 0;
} |

8. Tableau de Structures

Nous pouvons créer un tableau de structures. Le tableau aura des structures individuelles comme ses éléments.

| | / Écrire un programme pour accepter et imprimer les détails d’un employé /
/ 75_array.c  /
#include
struct emp
{
int eno;
char name[20];
float sal;
};
int main()
{
struct emp e [10];
int i;
for(i = 0; i<10; i++)
{
printf(“Entrez le numéro de l’employé    :”); scanf(“%d”, &e [i].eno);
printf(“Entrez le nom de l’employé       :”); scanf(“%s”, e [i].name);
printf(“Entrez le salaire de l’employé     :”); scanf(“%d”, &e [i].sal);
}
printf(“\n\nLes détails de l’employé sont les suivants…. “);
for(i = 0; i<10; i++)
printf(“%d    %s      %d”, e [i].eno, e [i].name, e [i].sal);
return 0;
} |

Rien de nouveau dans le programme ci-dessus. L’ensemble du programme est le même que le programme structuré simple sauf les données marquées.

9. Tableaux dans les Structures

Il peut y avoir une situation pour utiliser des tableaux dans les structures. Comment réaliser des tableaux dans les structures. Voici l’approche avec un programme simple.

| | / Programme pour accepter et imprimer les informations d’un étudiant  /
/ 76_array.c /
#include
struct stud
{
int sno;
char name[10];
int marks[5];                              / Tableau dans la structure /
};
int main()
{
struct stud s;
int i;
printf(“Entrez le numéro de l’étudiant  “); scanf(“%d”, &s.sno);
printf(“Entrez le nom de l’étudiant          “); scanf(“%s”, s.name);
for( i = 0; i<3; i++)
{
printf(“Entrez les notes de l’étudiant  “); scanf(“%d”, &s.marks[i]);
}
printf(“\n\nLes dossiers des étudiants sont les suivants…. “);
printf(“%d  %s  %d  %d  %d”, s.sno, s.name, s.marks[0], s.marks[1], s.marks[2] );
return 0;
} |

10. Passer des Structures à des Fonctions

Il est possible d’envoyer des structures entières à des fonctions en tant qu’arguments dans l’appel de fonction. La variable de structure est traitée comme n’importe quelle variable ordinaire.

| | / Programme pour passer une variable de structure à une fonction /
/ 77_funct.c /
#include
struct emp
{
int eno;
char name[10];
float sal;
};
void display(struct emp temp);
int main()
{
struct emp e;
display(e);
return 0;
}
void display(struct emp temp)
{
printf(“%d  %s  %d”, temp.eno, temp.name, temp.sal );
} |

11. Retourner des Structures depuis des fonctions

Nous pouvons retourner des structures depuis des fonctions. Oui, les structures peuvent être retournées depuis des fonctions tout comme des variables de tout autre type.

| | / Retourner un objet de structure depuis une fonction /
/ 78_funct.c /
struct emprec
{
int eno;
char name[10];
};
struct emprec read();
void write(struct emprec t);
int main()
{
struct emprec e;
e = read();
write(e);
return 0;
}
void write(struct emprec t)
{
printf(“\n\n%d  %s”, t.eno, t.name);
}
struct emprec read()
{
struct emprec t;
printf(“Entrez le numéro de l’employé   :”); scanf(“%d”, &t.eno);
printf(“Entrez le nom de l’employé         :”); scanf(“%s”, t.name);
return t;
} |

12. Pointeur vers une Structure

Jusqu’à présent, nous avons vu que les membres d’une structure peuvent être de types de données comme int, char, float ou même structure. Le langage C/C++ permet également de déclarer une variable pointeur comme membre d’une structure. Les variables pointeur peuvent être utilisées pour stocker l’adresse d’une variable de structure également. Un pointeur peut être déclaré comme s’il pointe vers un type de données de structure.

| | / Programme pour démontrer le processus de Pointeur vers une structure /
/ 79_pointer.c /
#include
struct employee
{
int eno;
char name[10];
};
struct employee emp;
int main()
{
emp = (struct employee )malloc(sizeof(emp));
printf(“Entrez les détails de l’employé ..”);
scanf(“%d%s%”, &emp->eno, emp->name);
printf(“\n\n%d   %s”, emp->eno, emp->name);
return 0;
} |

Les données marquées sont essentielles pour implémenter le pointeur vers la structure.
La déclaration suivante est optionnelle, mais il est préférable de l’utiliser pour mieux organiser la gestion de la mémoire.
emp = (struct employee * )malloc(sizeof(emp));

13. Structures Contenant des Pointeurs

Une variable pointeur peut également être utilisée comme membre dans la structure.
Le programme suivant contient des membres pointeur contenus par une variable pointeur de structure.

| | / programme pour démontrer l’utilisation de structures contenant des Pointeurs /
/ 80_pointers.c  /
#include
struct
{
int a;
int b;
} *temp;
int main()
{
int x, y;
x = 20; y = 50;
rk -> a = &x;
rk -> b = &y;

printf(“%d %d “, temp->a, temp->b );
return 0;
} | | | sortie :
20    50 |

14. Structures Auto-référentielles

Les structures peuvent avoir des membres, qui sont du type de la même structure elle-même dans laquelle elles sont incluses. Cela est possible avec des pointeurs et le phénomène est appelé structures auto-référentielles.

| | struct emp
{
int eno;
char name[10];
struct emp *e;
}; |

Les structures auto-référentielles peuvent être utilisées principalement pour organiser des données, trier, rechercher des éléments, insérer, supprimer des éléments, etc.

Cette approche conduit à des structures de données (c’est-à-dire, Listes Chaînées, Piles, Files d’attente, Arbres et Graphes).