IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C Discussion :

Problème appel de fonctions


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2017
    Messages
    4
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Somme (Picardie)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2017
    Messages : 4
    Par défaut Problème appel de fonctions
    Bonjour à tous,
    Je vous présente mon problème, j'ai un petit soucis lors de mon exécution de mon programme. Je m'explique je suis étudiant en informatique et j'ai un TP concernant les structures pointeurs... J'ai plusieurs fonctions a compléter ce que j'ai fais avec succès (je pense ). Le petit problème est que lors de l’exécution du programme je me retrouve avec un message d'erreur : Segmentation fault (Core dumped). Ce problème si mes souvenirs sont bon signifie le plus souvent que l'on divise quelque chose par 0. Or je ne vois pas de division par 0 dans mon programme, je ne comprend donc pas comment terminer ce TP. S'il quelqu'un peux m'indiquer et me mettre dans la bonne voie je lui en serait très reconnaissant. Je vous met l'énoncé et mon programme (au cas où j'aurai fait d'énormes erreurs) :

    Énoncé :
    Donnez la forme finale suivante à la fonction principale : lecture d’une donnée temporelle ; affichage de cette valeur ; affichage des dix valeurs suivantes, chacune sur une nouvelle ligne ; affichage des dix valeurs qui précèdent la dernière valeur affichée, chacune sur une nouvelle ligne ; affichage d’un compte à rebours de la dernière valeur affichée jusqu’à 0 h 0 min 0 s 0 cs, l’affichage de chaque nouvelle valeur se superposant à celui de la précédente (grâce au caractère retour charriot).

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    #include <stdlib.h>
    #include <stdio.h>
     
    //--- définition du type stime -------------------------------------------------
     
    //  Le type stime est capable de mémoriser une donnée temporelle limitée à une
    //    période de HOUR_PER_DAY heures et à une précision d'un centième de
    //    seconde. La plus petite donnée mémorisable correspond à 0 heure, 0 minute,
    //    0 seconde, 0 centième de seconde, la plus grande à
    //    (HOUR_PER_DAY - 1) heures, (MIN_PER_HOUR - 1) minutes,
    //    (SEC_PER_MIN - 1) secondes, (HSEC_PER_SEC - 1) centièmes de seconde
     
    typedef struct {
      int hour;
      int min;
      int sec;
      int hsec;
    } stime;
     
    #define HOUR_PER_DAY  24
    #define MIN_PER_HOUR  60
    #define SEC_PER_MIN   60
    #define HSEC_PER_SEC  100
     
    #define FUN_SUCCESS 0
    #define FUN_FAILURE -1
     
    //--- déclaration des opérations sur le type stime -----------------------------
     
    typedef enum { NEW_LINE, CARRIAGE_RETURN } stime_print_ending;
     
    //  stime_pack : initialise la variable pointée par stptr à partir des données
    //    h heures, m minutes, s secondes et hs centièmes de seconde fournies.
    //    Renvoie 0 en cas de succès et une valeur non nulle en cas d'échec. En cas
    //    d'échec, la variable pointée par stptr n'est pas modifiée
    int stime_pack(int h, int m, int s, int hs, stime *stptr);
     
    //  stime_unpack : restitue sous la forme heures, minutes, secondes et centièmes
    //    de seconde la donnée temporelle mémorisée par la variable pointée par
    //    stptr en l'affectant aux variables pointées par hptr, mptr, sptr et hsptr
    void stime_unpack(const stime *stptr,
        int *hptr, int *mptr, int *sptr, int *hsptr);
     
    //  stime_scan : initialise la variable pointée par stptr à partir des données
    //    heures, minutes, secondes et centièmes de seconde lues sur l'entrée
    //    standard. Renvoie 0 en cas de succès et une valeur non nulle en cas
    //    d'échec. En cas d'échec, la variable pointée par stptr n'est pas modifiée
    int stime_scan(stime *stptr);
     
    //  stime_print : écrit sur la sortie standard la décomposition heures, minutes,
    //    secondes et centièmes de seconde de la donnée temporelle mémorisée par la
    //    variable pointée par stptr. Le format de sortie est "hh:mm:ss:hs".
    //    L'affichage est suivi du caractère nouvelle ligne '\n' ou retour charriot
    //    '\r' selon que ending vaut NEW_LINE ou CARRIAGE_RETURN
    void stime_print(const stime *stptr, stime_print_ending ending);
     
    //  stime_incr : augmente la donnée temporelle mémorisée par la variable pointée
    //    par stptr d'un centième de seconde au modulo HOUR_PER_DAY heures, avec, le
    //    cas échéant, passage de la plus grande donnée mémorisable à la plus petite
    void stime_incr(stime *stptr);
     
    //  stime_decr : diminue la donnée temporelle mémorisée par la variable pointée
    //    par stptr d'un centième de seconde au modulo HOUR_PER_DAY heures, avec, le
    //    cas échéant, passage de la plus petite donnée mémorisable à la plus grande
    void stime_decr(stime *stptr);
     
    //  stime_compar : renvoie 0, une valeur strictement négative ou strictement
    //    positive selon que la donnée temporelle mémorisée par la variable pointée
    //    par stptr1 est égale, strictement inférieure ou strictement supérieure à
    //    celle mémorisée par la variable pointée par stptr2
    int stime_compar(const stime *stptr1, const stime *stptr2);
     
    int main(void){
      stime *stptr = NULL;
      stime_scan(stptr);
      stime_print(stptr, NEW_LINE);
      return EXIT_SUCCESS;
    }
     
    int stime_pack(int h, int m, int s, int hs, stime *stptr){
      if (!(0 <= h && h <= HOUR_PER_DAY)
          && (0 <= m && m <= MIN_PER_HOUR)
          && (0 <= s && s <= SEC_PER_MIN)
          && (0 <= hs && hs <= HSEC_PER_SEC)){
            return FUN_FAILURE;
          } else {
            stptr -> hour = h;
            stptr -> min = m;
            stptr -> sec = s;
            stptr -> hsec = hs;
            return FUN_SUCCESS;
          }
    }
     
    void stime_unpack(const stime *stptr,
        int *hptr, int *mptr, int *sptr, int *hsptr){
          *hptr = stptr -> hour;
          *mptr = stptr -> min;
          *sptr = stptr -> sec;
          *hsptr = stptr -> hsec;
    }
     
    int stime_scan(stime *stptr){
      int h;
      int m;
      int s;
      int hs;
      if (scanf("%d%d%d%d", &h, &m, &s, &hs) != 4){
        return FUN_FAILURE;
      } else {
        stime_pack(h, m, s, hs, stptr);
        return FUN_SUCCESS;
      }
    }
     
    void stime_print(const stime *stptr, stime_print_ending ending){
      int *hptr = NULL;
      int *mptr = NULL;
      int *sptr = NULL;
      int *hsptr = NULL;
      stime_unpack(stptr, hptr, mptr, sptr, hsptr);
      printf("%d : %d : %d : %d", *hptr, *mptr, *sptr, *hsptr);
      if (ending == NEW_LINE){
        printf("\n");
      }else{
        printf("\r");
      }
    }
     
    void stime_incr(stime *stptr){
      stptr -> hsec += 1;
     
      stptr -> sec += stptr -> hsec / HSEC_PER_SEC;
      stptr -> min += stptr -> sec / SEC_PER_MIN;
      stptr -> hour += stptr -> min / MIN_PER_HOUR;
     
      stptr -> hour %= HOUR_PER_DAY;
      stptr -> min %= MIN_PER_HOUR;
      stptr -> sec %= SEC_PER_MIN;
      stptr -> hsec %= HSEC_PER_SEC;
    }
     
    void stime_decr(stime *stptr){
      stptr -> hsec -= 1;
     
      stptr -> sec -= stptr -> hsec / HSEC_PER_SEC;
      stptr -> min -= stptr -> sec / SEC_PER_MIN;
      stptr -> hour -= stptr -> min / MIN_PER_HOUR;
     
      stptr -> hour %= HOUR_PER_DAY;
      stptr -> min %= MIN_PER_HOUR;
      stptr -> sec %= SEC_PER_MIN;
      stptr -> hsec %= HSEC_PER_SEC;
    }
     
    int stime_compar(const stime *stptr1, const stime *stptr2){
      if (stptr1 == stptr2){
        return FUN_SUCCESS;
      } else if (stptr1 < stptr2){
        return FUN_FAILURE;
      } else {
        return 1;
      }
    }
    Merci d'avance et bonne journée

  2. #2
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    Septembre 2007
    Messages
    7 480
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 480
    Par défaut
    Bonjour et bienvenue,

    Une erreur de segmentation (ou segfault) n'est pas le résultat d'une division par zéro : c'est une interruption volontaire de ton programme à l'initiative du micro-processeur, qui refuse de l'exécuter car il a fait un accès mémoire (en lecture ou en écriture) en dehors du segment réservé à ton processus et qu'en clair, il était sur le point d'écraser ses voisins, voire le système lui-même. C'est en réalité extrêmement fréquent, et cela est dû soit à un pointeur mal initialisé, soit à un dépassement de tableau, soit encore à au débordement d'un buffer lorsque celui-ci est à la charge d'une fonction tierce.

    Dans ton cas, il est intéressant d'apprendre d'ores et déjà à utiliser un debugger. Tu t'en serviras toute ta carrière. Avec GDB, on obtient :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    Program received signal SIGSEGV, Segmentation fault.
    0x000000000040067c in stime_pack (h=1, m=2, s=3, hs=4, stptr=0x0) at programme.c:87
    87	        stptr -> hour = h;
    … ainsi que :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    (gdb) bt
    #0  0x000000000040067c in stime_pack (h=1, m=2, s=3, hs=4, stptr=0x0) at programme.c:87
    #1  0x0000000000400748 in stime_scan (stptr=0x0) at programme.c:111
    #2  0x0000000000400612 in main () at programme.c:75
    Donc, ta fonction stime_scan() passe un pointeur nul à ta fonction stime_pack() chargée de la remplir, lui-même transmis par main(). Et dans main(), on voit :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    int main(void){
      stime *stptr = NULL;
      stime_scan(stptr);
      stime_print(stptr, NEW_LINE);
      return EXIT_SUCCESS;
    }
    … donc en fait, tu initialises proprement un pointeur sur une structure stime mais tu ne réserves pas la structure elle-même.

    Pour arranger ça, soit tu passes par malloc() pour initialiser ton pointeur et tu penses à faire un free() avant de partir, soit alloues directement une variable de type « struct stime » plutôt qu'un pointeur, et tu passes l'adresse de cette variable à l'aide de l'opérateur « & ».

    À part cela, ton commentaire et ton code sont clairs et très bien écrits ! Félicitations.

  3. #3
    Expert éminent

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 202
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 202
    Par défaut
    non, "segmentation fault" n'est pas une "division by 0", c'est une erreur de … segmentation.

    En fait, la mémoire est vue par un programme comme un ensemble de segments, ayant des propriétés spécifiques:
    • un segment totalement interdit d'accès, qui contient l'adresse 0 (raison pour laquelle cette adresse défini un pointeur invalide).
    • un segment contenant le code du programme, normalement interdit d'écriture.
    • le tas, la pile,
    • un autre segment pour les variables statiques, (en général, mais je jurerai pas que c'est systématique)
    • Les chaines de caractères littérales (comme "coin coin") se trouvent plus ou moins avec le programme. Elles sont normalement dans un segment qui ne peut pas être écrit.

    Une erreur de segmentation, c'est se tromper de segment. Par exemple, écrire dans un emplacement mémoire en lecture seul, ou lire où c'est interdit

    La faute est quasiment toujours une instruction qui se résume à *NULL (ou NULL->, c'est à dire utiliser le pointé d'un pointeur invalide (car on n'a pas vérifié qu'il est bon à temps).

    A priori, je parierai sur stime_unpack. Et pour être précis, son appel. En effet, tu appelles la fonction en lui donnant 4 NULL, et elle appelle -> dessus

    La valeur d'un pointeur est l'adresse d'un bloc mémoire.
    Celle-ci peut s'obtenir soit avec l'opérateur & sur une variable du bon type (ce sera l'adresse d'une variable dans la pile, qui restera valide tant que la variable est définie)
    soit avec malloc (et autre) qui retourne une adresse d'un bloc mémoire explicitement demandé au système, et qu'il faudra rendre explicitement (une et une seule fois).

    Je t'invite autant que possible à utiliser la première, à moins d'avoir une bonne raison.
    Le pire, c'est que tu as fait exactement la bonne chose avec scanf dans stime_scan().

    Edit: zut, doublé, mais pas pour la même instance de la faute

  4. #4
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2017
    Messages
    4
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Somme (Picardie)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2017
    Messages : 4
    Par défaut
    Tout d'abord, merci à vous pour vos réponses claires et précises. J'avoue avoir un peu de mal à comprendre mon erreur malgré vos explications très claires. Je comprend mieux l'erreur du "Segmentation fault", en effet en y réfléchissant je me rend compte que cela correspond à un problème de segment liée à la mémoire. Les notions de segment de code, segment de données... sont assez bien encrée, mais j'avoue ne pas réellement comprendre l'histoire de pointeur.
    Je ne vois pas comment faire appel à ma fonction stime_unpack, j'ai essayé ceci mais sans succès :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    void stime_print(const stime *stptr, stime_print_ending ending){
      int h;
      int m;
      int s;
      int hs;
      stime_unpack(stptr, &h, &m, &s, &hs);
      .
      .
      .
    }
    Je pense que j'ai du mal à comprendre cette notion-ci :
    La faute est quasiment toujours une instruction qui se résume à (ou, c'est à dire utiliser le pointé d'un pointeur invalide (car on n'a pas vérifié qu'il est bon à temps).

  5. #5
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    Septembre 2007
    Messages
    7 480
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 480
    Par défaut
    Un « pointeur » est une variable ou une expression qui « pointe » (du doigt) un autre objet en mémoire. Autrement dit, c'est une variable qui contient une adresse mémoire, et en général l'adresse mémoire d'un objet d'un certain type. Quand tu écris :

    … tu déclares un pointeur qui, pour l'instant pointe l'adresse 0x00000000 (le début du plan mémoire, où il ne peut rien se trouver et dont la valeur est choisie pour représenter justement l'absence de valeur). À*ce endroit, il n'y a rien et tu n'as pas le droit non plus d'y accéder.

    Soit tu déclares une vraie structure stime :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    stime st; /* Sans étoile "*" */
    … et tu passes l'adresse de cette variable à ta fonction pour qu'elle puisse aller écrire dedans :

    … soit tu alloues dynamiquement de la mémoire avec malloc() en stockant dans ton pointeur stptr la valeur renvoyée par celle-ci. Et tu penses à la libérer à la fin avec free().

  6. #6
    Expert éminent

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 202
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 202
    Par défaut
    Citation Envoyé par Quickly76 Voir le message
    Je ne vois pas comment faire appel à ma fonction stime_unpack, j'ai essayé ceci mais sans succès :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    void stime_print(const stime *stptr, stime_print_ending ending){
      int h;
      int m;
      int s;
      int hs;
      stime_unpack(stptr, &h, &m, &s, &hs);
    }
    En fait, c'est la bonne chose à faire. Si tu as l'impression que c'est sans succès, c'est parce que l'autre erreur (de même nature) survient avant.

  7. #7
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2017
    Messages
    4
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Somme (Picardie)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2017
    Messages : 4
    Par défaut
    Bonsoir à tous,
    C'est désormais beaucoup plus clair en ce qui concerne les adresse de pointeurs, les défauts de segmentation...
    Mais après avoir réfléchi toute la journée je me rend compte que mon programme ne fonctionne pas sur la fonction decrease ainsi que sur la fonction compar.
    Je ne vois pas pour la fonction compar comment faire lire deux données temporelles sur l'entrée sachant que mes pointeur sont déclaré en constante.
    Je vous met les deux fonctions qui me donne du fil à retordre peut-être est-ce encore une erreur toute bête ?

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    void stime_decr(stime *stptr){
      stptr -> hsec -= 1;
     
      stptr -> sec += stptr -> hsec / HSEC_PER_SEC;
      stptr -> min += stptr -> sec / SEC_PER_MIN;
      stptr -> hour += stptr -> min / MIN_PER_HOUR;
     
      stptr -> hour %= HOUR_PER_DAY;
      stptr -> min %= MIN_PER_HOUR;
      stptr -> sec %= SEC_PER_MIN;
      stptr -> hsec %= HSEC_PER_SEC;
    }
     
    int stime_compar(const stime *stptr1, const stime *stptr2){
      if (stptr1 == stptr2){
        return FUN_SUCCESS;
      } else if (stptr1 < stptr2){
        return FUN_FAILURE;
      } else {
        return 1;
      }
    }
    Dans ma fonction decrease j'ai essayé de mettre des printf après chaque valeur pour voir si elle faisait son travail mais impossible de trouver d'où provient mon erreur mes hs passe en négatif.
    En tout cas, merci beaucoup pour votre aide.

  8. #8
    Expert confirmé
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    Décembre 2015
    Messages
    1 599
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Décembre 2015
    Messages : 1 599
    Par défaut
    Bonjour,
    Je ne vois pas ce que tu cherches à faire dans la stime_drcr().
    Ce que je ferais :
    - décrementer hsec, s'il est devenu négatif, il devient 100-1 et
    - décrementer sec, s'il est devenu négatif, il devient 60-1 et
    - décrementer min, s'il est devenu négatif, il devient 60-1 et
    - décrementer hour, s'il est devenu négatif, il devient 24-1.

    Pour la fonction stime_compar(), tu compares les pointeurs pour trouver la plus petite date, il faudrait plutôt comparer les données pointées, en faisant :
    - si stptr1->hour == stptr2->hour et
    - si stptr1->min == stptr2->min ......

Discussions similaires

  1. problème appel de fonction
    Par pepsi33 dans le forum C++
    Réponses: 7
    Dernier message: 30/09/2007, 14h03
  2. Problème appel de fonction
    Par pepsi33 dans le forum C++
    Réponses: 1
    Dernier message: 30/09/2007, 11h40
  3. problème appel à une fonction pl/sql
    Par tommey dans le forum Langage
    Réponses: 3
    Dernier message: 07/08/2007, 14h19
  4. [PHP-JS] Problème appel de fonction php
    Par Didibzh dans le forum Langage
    Réponses: 10
    Dernier message: 12/06/2007, 16h55
  5. Réponses: 10
    Dernier message: 08/12/2006, 02h18

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo