Annonce

Réduire
Aucune annonce.

Cours langage C n°13 - Définition de synonymes

Réduire
Ceci est une discussion importante.
X
X
  • Filtre
  • Heure
  • Afficher
Tout nettoyer
nouveaux messages

  • Cours langage C n°13 - Définition de synonymes

    Définition de synonymes

    Attention: Syntaxe à prendre avec des pincettes, peut nuire gravement à la lisibilité d'un code

    Il est possible de donner des synonymes à des types de variables, imaginons que au lieu de créer un tableau de 2 flottants, vous souhaiteriez modifier cette déclaration ci-dessous

    Code:
    float A[2];
    en

    Code:
    point A; /* coordonnées du point A */
    Nous aurons créés un synonyme du type float nommé point.

    Cet exemple concret reste raisonnable et acceptable, attention toujours de rendre le nom de vos synonymes compréhensibles.

    Syntaxe

    Pour créer un synonyme de type, on utilisera le mot clé typedef...

    Pour créer notre point de coordonnées x, y (tableau de 2 flottants), on fera comme ceci

    Code:
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef float point[2]; /* création du synonyme type float par point */
    
    int main(void)
    {
        point A; /* déclaration du point A de coordonnées x, y */
    
        float x = 12.5; /* déclaration des coordonnées à enregistrer */
        float y = 8.2;
    
        A[0] = x; /* assignation des coordonnées du point A */
        A[1] = y;
    
        printf("Le point A est de coordonnées x=%f et y=%f\n", A[0], A[1]); /* Affichage des coordonnées */
    
        return 0;
    }
    Remarque:

    typedef est utilisé en dehors de la fonction main

    Paramètre de fonction

    En tant que paramètre de fonction, il n'y a pas de surprise

    Code:
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef float point[2];
    void displayCoordinates(point A);
    
    int main(void)
    {
    
    
        point A;
    
        float x = 12.5;
        float y = 8.2;
    
        A[0] = x;
        A[1] = y;
    
        displayCoordinates(A);
    
        return 0;
    }
    
    void displayCoordinates(point N)
    {
        printf("Le point est de coordonnées x=%f et y=%f\n", N[0], N[1]);
    }
    Structure

    Ah là on rentre dans la partie où typedef est le plus souvent utilisé, regardez plutôt la clarté sur une structure

    Code:
    typedef struct
    {
        float x;
        float y;
    } Point;
    Nous avons créé une structure Point prenant deux types float nommés x et y

    Le code modifié sera plus clair au lecteur

    Code:
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct
    {
        float x;
        float y;
    } Point;
    
    void displayCoordinates(Point A);
    
    int main(void)
    {
    
    
        Point A; /* Déclaration d'un point A de coordonnées x, y */
    
        float x = 12.5;
        float y = 8.2;
    
        A.x = x; /* Assignation de la coordonnée x du point A */
        A.y = y; /* Assignation de la coordonnée y du point A */
    
        displayCoordinates(A); /* Affichage des coordonnées de A */
    
        return 0;
    }
    
    void displayCoordinates(Point A)
    {
        printf("Le point est de coordonnées x=%f et y=%f\n", A.x, A.y);
    }
    Ouais mais si je veux modifier les coordonnées de A ?

    Pas le choix, vous l'aurez deviné, il nous faut les pointeurs

    Code:
    void modify(Point *N, float x, float y)
    {
        N->x = x;
        N->y = y;
    }
    Remarque:

    modify est une fonction prenant en paramètres l'adresse d'une structure Point nommée N, et les coordonnées à réassigner x, y.
    N->x équivalent à (*N).x permet un petit raccourci, -> est un opérateur permettant l'assignation d'une valeur directement par l'adresse de la variable

    Le code fonctionnel est le suivant

    Code:
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct
    {
        float x;
        float y;
    } Point;
    
    void modify(Point *N, float x, float y);
    void displayCoordinates(Point A);
    
    int main(void)
    {
    
    
        Point A;
    
        float x = 12.5;
        float y = 8.2;
    
        modify(&A, x, y); /* en paramètre l'adresse d'une structure, d'où le & */
    
        displayCoordinates(A);
    
        return 0;
    }
    
    void modify(Point *N, float x, float y)
    {
        N->x = x;
        N->y = y;
    }
    
    void displayCoordinates(Point A)
    {
        printf("Le point est de coordonnées x=%f et y=%f\n", A.x, A.y);
    }
    Conseils

    Évidemment vous faîtes comme vous le souhaitez, je conseille l'utilisation de typedef juste pour la création de vos structures, car son utilisation à toutes les sauces peuvent rendre votre code illisible. Pensez toujours que en tant que professionnel d'autres liront vos codes, et en tant que débutant, en relisant 1 mois plus tard vous risquez de ne plus vous comprendre...

    EXERCICES

    Créer une structure Personne, comprenant les données suivantes
    • nom (25 caractères maximum)
    • prenom (25 caractères maximum)
    • telephone (exemple 0652984723) (10 caractères maximum)

    Créer une fonction creerPersonne, prenant en paramètre nom, prenom et telephone et retournant une structure Personne

    Code:
    Personne creerPersonne(const char *nom, const char *prenom, char *telephone)
    {
        /* code */
    }
    Créer une fonction modifierPhone, ne retournant rien, et prenant en paramètre l'adresse d'une structure Personne, et le nouveau numéro de télephone

    Code:
    void modifierPhone(Personne *pers, const char *phone)
    {
        /* code */
    }
    Créer une fonction displayPersonne, affichant toutes les informations de la personne (nom, prénom et téléphone)

    Code:
    void displayPersonne(Personne pers)
    {
        /* code */
    }
    Utilisez dans votre fonction main, les fonctions créées et surtout celle permettant de modifier un numéro de téléphone d'une personne.
    Vérifier ces fonctions avec la fonction displayPersonne et regarder si le téléphone de la personne est bien modifié

    Merci de m'avoir lu et à bientôt pour le prochain cours

  • #2
    Bonjour,

    Après quelques soucis :

    Code:
    #include <stdio.h>
    #include <string.h>
    
    typedef struct
    {
        char nom[25];
        char prenom[25];
        char telephone[10];
    
    } Personne;
    
    Personne creerPersonne(const char *nom, const char *prenom, const char *telephone);
    
    void modifierPhone(Personne *pers, const char *phone);
    
    void displayPersonne(Personne pers);
    
    int main(void)
    {
    
        char nom[25] = "Patrick";
        char prenom[25] = "Paul";
        char telephone[10] = {'0','6','0','9','0','5','0','3','0','\0'};
        char nvTel[10] = {'0','9','0','9','0','5','0','3','0','\0'};
        Personne Test;
    
    
        Test = creerPersonne(nom,prenom,telephone);
    
        modifierPhone(&Test,nvTel);
    
        displayPersonne(Test);
    
        return 0;
    
    }
    
    Personne creerPersonne(const char *nom, const char *prenom, const char *telephone)
    {
        Personne nouvellePersonne;
    
        strcpy(nouvellePersonne.nom,nom);
        strcpy(nouvellePersonne.prenom,prenom);
        strcpy(nouvellePersonne.telephone,telephone);
    
        return nouvellePersonne;
    }
    
    void modifierPhone(Personne *pers, const char *phone)
    {
        strcpy((*pers).telephone,phone);
    }
    
    void displayPersonne(Personne pers)
    {
        printf("Nom : %s\n", pers.nom);
        printf("Prenom : %s\n", pers.prenom);
        printf("Tel : %s\n\n", pers.telephone);
    }
    Juste une petite chose pour savoir si j'ai bien compris le truc :

    Code:
    strcpy((*pers).telephone,phone);
    Ici la variable "pers" contient une adresse de structure de type "Personne", on doit donc la déréférencer pour accéder au début de la structure, la fonction "strcpy" attend une adresse en paramètre, donc si on fait (*pers).tableau on aura bien l'adresse de la première case du tableau ?

    Sous forme de schéma :

    ADRESSE ||| VARIABLE ||| VALEUR

    FFFFFF1 ||| pers______ ||| FFFFFF2
    FFFFFF2 ||| Test.tel___ ||| FFFFFF3
    FFFFFF3 ||| Test.tel[0] ||| 06020501...
    Dernière modification par shirocen, 20 janvier 2015, 16h34.
    deux et deux font cinq

    Commentaire


    • #3
      Ok, commençons par le code, il est correct, mais plutôt que cette mocheté :

      Code:
      strcpy((*pers).telephone,phone);
      on préférera :

      Code:
      strcpy(pers->telephone, phone);
      Ensuite la question,

      Ici la variable "pers" contient une adresse de structure de type "Personne", on doit donc la déréférencer pour accéder au début de la structure, la fonction "strcpy" attend une adresse en paramètre, donc si on fait (*pers).tableau on aura bien l'adresse de la première case du tableau ?
      Toujours difficile de te comprendre, ce qui prouve les difficultés de compréhension...

      Accéder au début de la structure ne veut rien dire.

      On dira plutôt qu'on accède à la structure par le biais de son adresse en la déréférençant.
      Déréférencer, veut dire accéder à une variable, valeur, objet par le biais d'une adresse.

      On attend ensuite non pas une adresse en paramètre, mais pour être précis, une adresse de type char, qui sera représenté ici par le 1er caractère de la variable telephone dans la structure Personne. En C on ne peut pas être imprécis.

      En voici une preuve

      Code:
      void modifierPhone(Personne *pers, const char *phone)
      {
          char *v = pers->telephone;
          strcpy(&v[0], phone);
      }
      ou

      Code:
      void modifierPhone(Personne *pers, const char *phone)
      {
          char *v = pers->telephone;
          strcpy(&(*v), phone);
      }
      Voilà, j'espère que j'ai été assez clair, c'est pas toujours simple à expliquer.

      Commentaire


      • #4
        Exercice :
        Code:
        #include <stdio.h>
        #include <string.h>
        
        typedef struct
        {
            char name[26];
            char firstname[26];
            char phone[11];
        }Personne;
        
        Personne creerPersonne(const char *nom, const char *prenom, char *telephone);
        void modifierPhone(Personne *pers, const char *phone);
        void displayPersonne(Personne pers);
        
        void main(void)
        {
            char a[] = "Dupont";
            char b[] = "Jean";
            char c[] = "0625485239";
        
        
            Personne p = creerPersonne(a, b, c);
            displayPersonne(p);
            modifierPhone(&p, "0624242424");
            displayPersonne(p);
            return 0;
        }
        
        
        Personne creerPersonne(const char *nom, const char *prenom, char *telephone)
        {
                Personne p;
                strcpy(p.name, nom);
                strcpy(p.firstname, prenom);
                strcpy(p.phone, telephone);
                return p;
        }
        
        void modifierPhone(Personne *pers, const char *phone)
        {
            strcpy(pers->phone, phone);
        }
        
        void displayPersonne(Personne pers)
        {
            printf("Nom : %s \n", pers.name);
            printf("Prénom : %s \n", pers.firstname);
            printf("Telephone : %s \n \n", pers.phone);
        }
        Dernière modification par Sadik, 25 janvier 2015, 15h28.
        Mon blog : http://rootsheep.info

        Commentaire


        • #5
          Il y a une erreur !

          Commentaire


          • #6
            Je ne vois pas à quel endroit ...
            Mon blog : http://rootsheep.info

            Commentaire


            • #7
              Concentres-toi sur ta fonction main

              Commentaire


              • #8
                Pourquoi ajouter const dans chaque paramètre de fonction?

                Code:
                 Personne creerPersonne(const char *nom, const char *prenom, char *telephone);
                Code:
                 void modifierPhone(Personne *pers, const char *phone);
                Sachant de le variables mise en paramètre lors de l'appelle fonction creerPersonne sont des char simples et que la modifierPhone consiste à modifier le numéro de téléphone qui ne doit donc pas être constant.


                Pour les personnes qui passeront après moi voici l'erreur de Sadik:




                Sa fonction main retourne 0 (return 0; ).
                Il déclare sa fonction main comme void (void main(void)).
                Dernière modification par Ephemeral25, 13 novembre 2016, 17h47.
                "la Connaissance pour un éveille de la Conscience"

                Commentaire


                • #9
                  Envoyé par Ephemeral25 Voir le message
                  Pourquoi ajouter const dans chaque paramètre de fonction?
                  Il me semble que cette question est fermée, ce qui veut dire que tu connais la réponse, et donc je pense qu'il serait de bon ton de proposer ta correction.

                  Sachant que si tu mets en doute le cours présenté, il faut bien prendre en compte les tenants et les aboutissants, et donc je te conseille de bien relire la problématique.

                  Maintenant que tu as bien tout relu correctement, j'attend tes propositions avec curiosité je dois dire... const est un mot clé connu en C, tu dois connaître son intérêt, non ?

                  Commentaire


                  • #10
                    EDIT: Affectivement j'ai mal compris.

                    Par reflexe sur chaque code je recherche à rendre chaque programme "modulaire", que l'utilisateur puisse rentrer lui même chaque valeur.
                    J'ai un peu survoler la consigne entrer un nom un prenom un numéro de téléphone.

                    Sache que je n'aurai jamais la prétention de remettre en cause aucun des threads sur le forum au vu de mon niveau. La question n'était pas fermé du coup
                    Dernière modification par Ephemeral25, 13 novembre 2016, 23h54.
                    "la Connaissance pour un éveille de la Conscience"

                    Commentaire

                    Chargement...
                    X