Structures et fonctions en C
Prérequis
Avant d'apprendre comment les pointeurs peuvent être utilisés avec des structures, assurez-vous de consulter les cours suivants:
Introduction
Comme tous les autres types, nous pouvons passer des structures en tant qu'arguments à une fonction. En fait, nous pouvons transmettre des membres individuels, des variables de structure, un pointeur sur des structures, etc., à la fonction. De même, les fonctions peuvent renvoyer un membre individuel ou des variables de structure, ou un pointeur sur la structure.
Passage d'une variable de structure en tant qu'argument d'une fonction
Le programme suivant montre comment nous pouvons passer une variable de structure comme argument à la fonction.
Exemple 1 :
#include < stdio.h>
struct etudiant{
char prenom[20];
int age;
};
void afficher(struct etudiant et)
{
printf(" prenom : %s \n", et.prenom);
printf(" age : %d \n", et.age);
}
int main(void)
{
struct etudiant et1 = {"Mostafa", 24};
afficher(et1);
return 0;
}
age : 24
Ici, une variable et1 de type "struct etudiant" est créée. La variable est passée à la fonction afficher() en utilisant afficher(et1);
Passer des pointeurs de structure comme Argument à une fonction(Passage par référence)
Bien que passer une variable de structure en tant qu'argument nous permette de transmettre tous les membres de la structure à une fonction, cette opération présente certains inconvénients :
- Rappelez-vous qu'une copie de la structure est transmise à l'argument formel. Si la structure est grande et que vous passez fréquemment des variables de structure, cela peut prendre un certain temps, ce qui rend le programme inefficace.
- De la mémoire supplémentaire est nécessaire pour enregistrer chaque copie de la structure.
Lors du passage par référence, les adresses mémoire des variables de structure sont transmises à la fonction.
Exemple 2 :
#include < stdio.h>
struct etudiant{
char prenom[20];
int age;
};
void afficher(struct etudiant *et)
{
printf(" prenom : %s \n", et->prenom);
printf(" age : %d \n", et->age);
}
int main(void)
{
struct etudiant et1 = {"Mostafa", 24};
afficher(&et1);
return 0;
}
age : 24
Exemple 3 :
#include < stdio.h>
struct complex{
float R; // partie réelle
float I; // Partie Imaginaire
};
void Ajouter(struct complex c1, struct complex c2, struct complex *res)
{
res->R=(c1.R + c2.R);
res->I=(c1.I + c2.I);
}
int main(void)
{
struct complex c1 = {2.5, 3}, c2={1.24,4}, somme;
Ajouter(c1, c2, &somme);
printf("res.R = %f et res.I = %f", somme.R,somme.I);
return 0;
}
Dans le programme ci-dessus, trois variables de structure c1, c2 et l'adresse du somme sont passées à la fonction Ajouter(). Ici, "somme" est passée par référence.
Lorsque la variable "res" à l'intérieur des Ajouter() est modifiée, la variable "somme" à l'intérieur de la fonction main() est également modifiée en conséquence.
Renvoyer une structure à partir d'une fonction
Tout comme nous pouvons renvoyer des types et des tableaux fondamentaux, nous pouvons également renvoyer une structure à partir d'une fonction.
Pour renvoyer une structure à partir d'une fonction, nous devons spécifier le type de retour approprié dans la définition et la déclaration de la fonction. Prenons l'exemple suivant:
struct etudiant Ajouter(char nom[],int age)
{
// corps de la fonction
}
Cette fonction accepte des arguments de type char[], int, et renvoie un argument de type struct etudiant.
Le programme suivant montre comment nous pouvons retourner une structure à partir d’une fonction.
Exemple 4 :
#include < stdio.h>
struct etudiant{
char prenom[20];
int age;
};
struct etudiant Saisir(){
// variable local;
struct etudiant e;
printf("Saisir le prénom : ");
scanf("%s",&e.prenom);
printf("saisir l'age : ");
scanf("%d",&e.age);
// retourner une copie de e;
return e;
}
int main(void)
{
struct etudiant et;
et=Saisir();
printf("voici vos infos : ");
printf("Prénom : %s",et.prenom);
printf("age : %d",et.age);
return 0;
}
saisir l'age : 25
voici vos infos :
Prénom : Mostafa
age : 25
Ici, la fonction Saisir() est appelée en utilisant et=Saisir(). La fonction retourne une structure de type struct etudiant. La structure renvoyée est affichée à partir de la fonction main().
Renvoyer un pointeur de Structure à partir d'une fonction
Dans la dernière section, nous avons appris qu'une fonction peut renvoyer une variable de structure. Il ne faut donc pas s'étonner qu'il puisse également renvoyer un pointeur sur une variable de structure.
Pour renvoyer un pointeur de structure à partir d'une fonction, il suffit de spécifier le type de retour approprié dans la définition et la déclaration de la fonction. Par exemple:
struct etudiant * Saisir(struct etudiant *e)
{
// corps de la fonction
}
Cette fonction accepte un argument de type pointeur sur "struct etudiant" et renvoie un pointeur de type "struct etudiant".
Le programme suivant montre comment nous pouvons renvoyer des pointeurs de structure à partir d’une fonction.
Exemple 5 :
#include < stdio.h>
struct etudiant{
char prenom[20];
int age;
};
struct etudiant *Saisir(struct etudiant *e){
printf("Saisir le prénom : ");
scanf("%s",&e->prenom);
printf("saisir l'age : ");
scanf("%d",&e->age);
return e;
}
int main(void)
{
struct etudiant et;
struct etudiant *et2;
et2=Saisir(&et);
printf("voici vos infos : \n");
printf("Prénom : %s \n",et2->prenom);
printf("age : %d",et2->age);
return 0;
}
saisir l'age : 26
voici vos infos :
Prénom : Mostafa
age : 26
