Langage C

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

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 nom[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;
                                }
                            
prenom : Mostafa
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 nom[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;
                                }
                            
prenom : Mostafa
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;
                                }
                            
res.R = 3.740000 et res.I = 7.000000

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 nom[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 le prénom : Mostafa
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 nom[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 le prénom : Mostafa
saisir l'age : 26
voici vos infos :
Prénom : Mostafa
age : 26

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :