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 :

Passage d'un tableau de structure


Sujet :

C

  1. #1
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2009
    Messages
    265
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2009
    Messages : 265
    Par défaut Passage d'un tableau de structure
    Bonjour,

    Je suis relativement novice en C (je code habituellement en Java) et je me torture l'esprit pour savoir :

    1) comment passer un tableau de structure à une fonction.

    2) trouver le nombre d'entrées dans la fonction sans être obligé de le passer en paramètre. J'ai essayé avec
    - sizeof(tableau) ou même
    - sizeof(tableau)/size(entrée)
    mais sizeof(tableau) renvoie toujours 0.

    3) retourner un nouveau tableau de structures pour remplacer l'ancien.


    Voici un test (qui n'a pas de d’intérêt réel) et qui bien sûr donne des erreurs de compilation. Merci d'avance à tous ceux qui voudront bien m'aider

    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
     
    #include <stdlib.h>
    #include <math.h>
    #include <string.h>
     
    typedef struct monElement
    {
           char nom[20], 
    	   prenom[20];
           int age;
    } ;
     
     
    monElement  * ajout_Einstein( monElement  *Ancien, int position)
    {
         int NombreEntrees; 
         int le = sizeof(monElement);
         int i;
    	 // NombreEntrees =   ??? //   Ici je ne sais pas comment faire
     
         struct monElement  Nouveau[NombreEntrees+1];  // nouveau tableau
     
         struct  monElement  ajout; 
         strcpy(ajout.nom,"Einstein");
         strcpy(ajout.prenom,"Albert");
         ajout.age = 28;
     
        for(i=0; i<=position ; i++)
        {
            Nouveau[i] = Ancien[i];
        }
     
        Nouveau[position] = ajout;  // On insère le nouvel élément
     
        for (i=position; i < NombreEntrees; i++)  
    		 Nouveau[i+1] = Ancien[i];
     
        return Nouveau;
    }
     
    int main()
    {
      struct monElement Ancien[5];  // on définit 5 entrées dans le tableau
     
      struct monElement x0; // first structure object
      strcpy(x0.nom,"Durand");
      strcpy(x0.prenom,"Pierre");
      x0.age = 42; 
      Ancien[0] = x0;
     
      struct monElement x1;  
      strcpy(x1.nom,"Martin");
      strcpy(x1.prenom,"Jean");
      x1.age = 17; 
      Ancien[1] = x1;
     
      struct monElement x2;  
      strcpy(x2.nom,"Poquelin");
      strcpy(x2.prenom,"Jean-Baptistet");
      x2.age = 62; 
      Ancien[2] = x2;
     
      struct monElement x3;  
      strcpy(x3.nom,"Camus");
      strcpy(x3.prenom,"Albert");
      x3.age = 38; 
      Ancien[3] = x3;
     
      struct monElement x4;  
      strcpy(x4.nom,"Dupont");
      strcpy(x4.prenom,"Robert");
      x4.age = 20; 
      Ancien[4] = x4; 
     
      struct monElement Nouveau[6];  
      Nouveau  = ajout_Einstein(&Ancien, 2); // ajout après la seconde entrée
    }

  2. #2
    Membre Expert
    Avatar de Metalman
    Homme Profil pro
    Enseignant-Chercheur
    Inscrit en
    Juin 2005
    Messages
    1 049
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Enseignant-Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 1 049
    Par défaut
    En C, tu dois soit délimiter, soit connaitre le nombre/taille/etc...

    Les 2 seules solutions que tu as :
    - pour N valeurs, tu alloues N+1 valeur, et tu mets la dernière à NULL (+ test si tu arrives à NULL)
    - passer en paramètre le nombre de valeurs

    Tu retrouves cet esprit dans la libC avec tous les strcpy/strncpy, strdup/strndup...
    --
    Metalman !

    Attendez 5 mins après mes posts... les EDIT vont vite avec moi...
    Les flags de la vie : gcc -W -Wall -Werror -ansi -pedantic mes_sources.c
    gcc -Wall -Wextra -Werror -std=c99 -pedantic mes_sources.c
    (ANSI retire quelques fonctions comme strdup...)
    L'outil de la vie : valgrind --show-reachable=yes --leak-check=full ./mon_programme
    Et s'assurer que la logique est bonne "aussi" !

    Ma page Developpez.net

  3. #3
    Modérateur

    Avatar de Bktero
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2009
    Messages
    4 493
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Loire Atlantique (Pays de la Loire)

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

    Informations forums :
    Inscription : Juin 2009
    Messages : 4 493
    Billets dans le blog
    1
    Par défaut
    Quand tu passes un tableau en paramètre à une fonction, tu passes en fait un pointeur sur son premier élément. Toute notion de taille du tableau. Tu ne connais plus que la taille d'un élément puisque c'est la taille du type. Il faut donc passer aussi en paramètre la taille du tableau (en nombre d'éléments). Un article que j'ai écrit à ce sujet : http://gradot.wordpress.com/2012/08/...ointeurs-en-c/

    Tu ne peux pas retourner un tableau local à une fonction non plus
    Il faut faire une allocation dynamique et retourner le pointeur obtenu, ou passer un autre pointeur en paramètre qui contiendra le résultat.

  4. #4
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2009
    Messages
    265
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2009
    Messages : 265
    Par défaut
    Merci à tous pour vos réponses qui me sont très utiles

  5. #5
    Membre Expert
    Avatar de imperio
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2010
    Messages
    869
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ain (Rhône Alpes)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mai 2010
    Messages : 869
    Par défaut
    Sinon tu peux toujours faire une structure qui contiendra ton tableau ainsi que sa taille.

  6. #6
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2009
    Messages
    265
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2009
    Messages : 265
    Par défaut
    Bonjour,

    J'ai donc essayé de faire comme l'on m'a suggéré, en utilisant une allocation dynamique dans la fonction. Cela marche de façon impec.

    Toutefois il reste deux points que j'ai du mal à résoudre : sans doute mon inexpérience et l'incompréhension (relative) de la façon dont marchent les pointeurs.

    1) Quand le nouveau tableau est renvoyé par la fonction, je suis tout à fait capable de récupérer l'élément inséré à la bonne place,mais incapable de savoir quelle est la taille du nouveau tableau. En fait, je ne sais pas comment dire que la zone allouée "Nouveau" est un tableau (c'est sans doute cela le problème).

    2) lorsque j'ai appelé la fonction en lui passant un tableau, il me retourne un tableau, et je voudrais remplacer L'ancien par le nouveau. Par exemple en écrivant : Ancien = Nouveau.
    Est-ce que c'est le pointeur au tableau "Ancien "qui est modifié ou le contenu du tableau ? (en supposant que le compilateur sache que "Nouveau" est aussi un tableau ce qui n'est pas le cas pour l'instant : erreur de compilation ).

    Ci-dessous le nouveau code. Merci encore pour toute l'aide que chacun de vous, les gourous, pouvez m'apporter.

    Gégé

    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
     
    #include <stdlib.h>
    #include <math.h>
    #include <string.h>
    #include <stdio.h> 
    typedef struct monElement
    {
           char nom[20], 
    	   prenom[20];
           int age;
    } ;
     
     
    monElement  * ajout_Einstein( monElement  *Ancien, int position, int taille)
    {
         int NombreEntrees; 
         int le = sizeof(monElement);
         int i;
    	 // NombreEntrees =   ??? //   Ici je ne sais pas comment faire
     
         struct monElement *Nouveau  ;
     
          Nouveau = ( struct monElement  *  ) malloc(sizeof(monElement)*(taille+1));
    	  printf("Taille de Ancien = %d\n",  taille);
     	  printf("Le nom du premier elements est = %s : \n", Ancien[0].nom);  
     
         struct  monElement  ajout; 
         strcpy(ajout.nom,"Einstein");
         strcpy(ajout.prenom,"Albert");
         ajout.age = 28;
     
        for(i=0; i<=position ; i++)
        {
            Nouveau[i] = Ancien[i];
        }
     
        Nouveau[position] = ajout;  // On insère le nouvel élément
     
        for (i=position; i < NombreEntrees; i++)  
    		 Nouveau[i+1] = Ancien[i];
     
        return Nouveau;
    }
     
    int main()
    {
      struct monElement Ancien[5];  // on définit 5 entrées dans le tableau
     
      struct monElement x0; // first structure object
      strcpy(x0.nom,"Durand");
      strcpy(x0.prenom,"Pierre");
      x0.age = 42; 
      Ancien[0] = x0;
     
      struct monElement x1;  
      strcpy(x1.nom,"Martin");
      strcpy(x1.prenom,"Jean");
      x1.age = 17; 
      Ancien[1] = x1;
     
      struct monElement x2;  
      strcpy(x2.nom,"Poquelin");
      strcpy(x2.prenom,"Jean-Baptistet");
      x2.age = 62; 
      Ancien[2] = x2;
     
      struct monElement x3;  
      strcpy(x3.nom,"Camus");
      strcpy(x3.prenom,"Albert");
      x3.age = 38; 
      Ancien[3] = x3;
     
      struct monElement x4;  
      strcpy(x4.nom,"Dupont");
      strcpy(x4.prenom,"Robert");
      x4.age = 20; 
      Ancien[4] = x4; 
     
     
      struct monElement *Nouveau  ;
      Nouveau = ajout_Einstein(&Ancien[0],  2, sizeof(Ancien)/sizeof(monElement)); // ajout après la seconde entrée
      printf("Le nom du troisieme element  est = %s : \n", Nouveau[2].nom); 
      printf("Taille de Nouveau = %d\n",   sizeof(Nouveau)/sizeof(monElement));
      Ancien = Nouveau;
    }

  7. #7
    Expert confirmé Avatar de Flodelarab
    Homme Profil pro
    Inscrit en
    Septembre 2005
    Messages
    5 287
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Charente (Poitou Charente)

    Informations forums :
    Inscription : Septembre 2005
    Messages : 5 287
    Par défaut
    Bonjour

    Tu nous indiques que tu viens du monde Java. En c, il n' y a pas de ramasse-miettes, donc la mémoire allouée DOIT être libérée. Dans ton programme, je vois bien un malloc, mais je ne vois pas de free. Tu réserves donc de la mémoire que tu ne libères jamais et que personne ne peut utiliser puisque tu ne l'as pas libérée. Et un jour, ton pc mettras un genou à taire par manque de mémoire.

    D'autre part, tu te poses des questions sur les pointeurs ancien et nouveau. Un pointeur n'est qu'un nombre qui désigne une première case. Si nouveau vaut 0x3265487 et ancien vaut 0x99568421, affecter l'un par l'autre donnera 0x99568421 et 0x99568421 dans les deux variables. Mais, ce qui est derrière (en clair, le tableau) il s'en moque.

    Enfin sizeof indique la taille de ce qu'il y a derrière (la structure si tu veux). Donc on sait que:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    sizeof(char)=1 // et oui, un octet par caractère
    sizeof(int)=4 // 4 octets pour un int
    Sizeof ne te donneras jamais la taille de ton tableau. Mais sizeof X nombre d'éléments permet de connaître la place prise en mémoire.

    Et comme tu ne rends pas la mémoire, tu connais la quantité de mémoire vive que tu bousilles

  8. #8
    Invité
    Invité(e)
    Par défaut
    Bonjour,

    En ce qui concerne l'utilisation du typedef, je te conseille la lecture de cette discussion datant d'hier.

    Ensuite sache que tu peux aisément réduire le code de remplissage de ton tableau Ancien comme ceci :

    Étant donné que tu passes la taille en paramètre, je ne comprends pas ce qui te bloques dans ton commentaire ligne 19

    Attention : contrairement au tableau de 5 élément pour lequel l'utilisation est correcte, sizeof(Nouveau)/sizeof(monElement) pour Nouveau, pointeur sur monElement, ne va pas renvoyer le nombre d'éléments qu'il contient. (Méthodes citées par Metalman à utiliser.)

    Ancien étant un tableau de 5 éléments, et Nouveau un pointeur, tu ne peux en aucun cas faire Ancien = Nouveau;, qui plus est avec un élément en plus.
    L'emplacement mémoire d'un tableau est fixe. Le mieux que tu puisses faire est faire pointer Nouveau vers un de ses éléments :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    int i = 2;
    Nouveau = Ancien + i;
    Ici, ton tableau Ancien n'est pas modifié. Tu alloues un espace mémoire (pointé par Nouveau) qui va contenir la copie des ses éléments avec le nouveau inséré entre. (N'oublie pas sa libération à la fin avec free().)

  9. #9
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2009
    Messages
    265
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2009
    Messages : 265
    Par défaut
    Merci à tous,

    j'ai essayé de suivre ces conseils que vous m'avez suggérés et ai résolu tous les problèmes qui restaient en suspend. Voici mon nouveau code (qui selon moi marche bien).

    - J'ai défini un synonyme pour la structure
    - je fais maintenant uniquement des allocations dynamiques pour les tableaux
    - Je termine chaque tableau par une entrée que j'appelle "null" ce qui me permet de trouver leur taille sans la passer en paramètre
    - Je libère la place de l'ancien tableau (j'espère ce que j'ai codé est correct).

    Si vous voyez encore des anomalies ou des améliorations possibles (je suis avide de bien programmer) n'hésitez pas.

    Encore merci pour votre aide précieuse.

    Gégé

    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
     
    #include <stdio.h>
    #include <stdlib.h>
     
     
    typedef struct maStructure 
    {
           char nom[20], 
    	   prenom[20];
               int age;
    }  monElement ;
     
    int tailleTableau(monElement *L)
    { 
      int taille = 0;
      while (true)
      {
      	if ( L[taille].age==0) break;
      	taille++;
      }
     return taille;	
    }
     
    monElement * allouerTableau(int n)
    {
    	  monElement *T  ;
    	  monElement null = {" ", " n", 0};	 // fin de tableau
          T= (monElement  *  ) malloc(sizeof(monElement)*(n+1));
          T[n] = null;
          return   T ;
    }
     
    monElement * inserer_element(monElement x, int n ,   monElement *L  )
     
    {
          int i = 0;
          int taille = tailleTableau(L);
     
          monElement *M  ;
     
          M=   allouerTableau(taille+1); 
    	  printf("Le nom du premier element  est = %s : \n", L[0].nom);  
     
          int nb = n-1;  // car l'index part à zéro 
          for(i=0; i<=nb ; i++)
          {
          	    M[i] = L[i];
          }
     
          M[nb] = x;  // On insère le nouvel élément
     
       for (i=nb; i<taille; i++)  M[i+1] = L[i];
       printf("Le nom du second elements est = %s : \n", M[1].nom);  
        free(L); // on libère l'espace de l'ancien tableau
       return    M ;
     
    }
     
     
    int main()
    {
       monElement   *monTableau;
       monTableau = allouerTableau(5);
       monTableau[0] = (monElement){"Durand", "Pierre", 42};
       monTableau[1] = (monElement){"Martin", "Jean", 17};
       monTableau[2] = (monElement){"Poquelin", "Jean-Baptistet", 62};
       monTableau[3] = (monElement){"Camus", "Albert", 38};
       monTableau[4] = (monElement){"Dupont", "Robert", 20}; 
     
      monElement ajout = {"De La Fontaine", "Jean", 71};	 
     
     
      printf("Taille de monTableau  avant insertion = %d\n\n",   tailleTableau(monTableau));
      monTableau = inserer_element(ajout, 3, monTableau ); // on ajoute cet élément à la 3ieme entrée
     
      printf("Le nom du troisieme element  est = %s : \n", monTableau[2].nom); 
     
      printf("\nTaille de monTableau  apres insertion = %d\n",   tailleTableau(monTableau));
    }

  10. #10
    Invité
    Invité(e)
    Par défaut
    Toi, tu m'as l'air de compiler en C++

    while (true) : le type bool (et ses valeurs true / false) n'existent pas en C.
    On a au mieux les macros introduites avec la norme C99 (la suite dans la FAQ).
    Tu pourrais simplement mettre la condition L[taille].age==0 dans le while(...) et enlever ton if.
    Et justement concernant cette condition, qu'en est-il si j'insère dans ton tableau un nouveau né ?

    Autre remarque : tu effectues une copie inutile :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    for(i=0; i<=nb ; i++)
    {
        M[i] = L[i];
    }
    Tu fais donc M[nb] = L[nb]; que tu écrases juste après par M[nb] = x;.

    Tu oublies de libérer la mémoire de monTableau à la fin.

    Le prototype du main est
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    int main(void) // ou int main(int argc, char *argv[])
    avec de préférence un return associé.

    Et histoire d'aller plus loin, qu'en est-il ...
    • si tes malloc() échouent ?
    • si l'on tente d'insérer un nouvel élément à une position négative ou plus grande que le tableau ?

  11. #11
    Modérateur

    Avatar de Bktero
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2009
    Messages
    4 493
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Loire Atlantique (Pays de la Loire)

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

    Informations forums :
    Inscription : Juin 2009
    Messages : 4 493
    Billets dans le blog
    1
    Par défaut
    Sizeof ne te donneras jamais la taille de ton tableau.
    Petite précision(déjà amorcée par Winjerome) : sizeof ne donne pas la taille d'un tableau alloué avec malloc(). En effet, on applique cet opérateur à un pointeur et il renvoie donc la taille de ce pointeur (souvent 4, qui est la taille d'un pointeur sur une machine 32 bits). Cela parce qu'il ne peut pas savoir que l'adresse contenue (dans le pointeur) est celle du début du zone réservée avec malloc().

    En revanche, si on l'applique à un vrai tableau, il renvoie la taille en octets de ce tableau. En effet, un tableau est une entité réelle et concrète. Le langage sait donc que cet objet est un tableau et connait la taille qu'il occupe en mémoire. C'est l'un des seuls cas où le tableau se distingue du pointeur. Voir la partie 2 de cet article. Une fois la taille complète et la taille d'un élément connues, on retrouve facilement le nombre d'éléments.


    Toi, tu m'as l'air de compiler en C++
    while (true) : le type bool (et ses valeurs true / false) n'existent pas en C.
    On a au mieux les macros introduites avec la norme C99 (la suite dans la FAQ).
    Bien vu ! Je croyais que stdbool était inclus dans stdlib, mais en fait non ^^

  12. #12
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2009
    Messages
    265
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2009
    Messages : 265
    Par défaut
    Citation Envoyé par Winjerome Voir le message
    Toi, tu m'as l'air de compiler en C++
    Non je code en C de base, car venant de Java, je ne vois pas l'intérêt (autre que la performance) pour coder en C++ qui est beaucoup plus compliqué (à mon avis) en particulier à cause de la gestion de la mémoire et des pointeurs. De plus java est portable sur toutes plateformes sans modification du code. J'ai porté le même code sur UNIX, LINUX, Windows, IBM 390 sans aucun problème.

    while (true) : le type bool (et ses valeurs true / false) n'existent pas en C.
    On a au mieux les macros introduites avec la norme C99 (la suite dans la FAQ).
    Tu pourrais simplement mettre la condition L[taille].age==0 dans le while(...) et enlever ton if.

    Avant de code l'instruction while (true), j'avais vérifié que cela était supporté depuis mai 2000 ( norme ISO/IEC 9899:1999 soit en court effectivement : C99). Je pense que depuis 13 ans, on a le droit d'utiliser cette "nouvelle" norme.

    Et justement concernant cette condition, qu'en est-il si j'insère dans ton tableau un nouveau né ?

    Autre remarque : tu effectues une copie inutile :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    for(i=0; i<=nb ; i++)
    {
        M[i] = L[i];
    }
    Tu fais donc M[nb] = L[nb]; que tu écrases juste après par M[nb] = x;.

    C'est une erreur, je voulais coder for (i= 0; i< n ; i++) pour m'arrêter à M[n-1]

    Tu oublies de libérer la mémoire de monTableau à la fin.
    Oui c'est vrai, mais comme le programme s'arrête, je pensais que ce n'était pas nécessaire.

    Le prototype du main est
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    int main(void) // ou int main(int argc, char *argv[])
    avec de préférence un return associé.
    Oui tu as raison, c'est un oubli.
    Et histoire d'aller plus loin, qu'en est-il ...
    • si tes malloc() échouent ?
    • si l'on tente d'insérer un nouvel élément à une position négative ou plus grande que le tableau ?

      Là aussi je suis d'accord avec toi, mais ce programme est juste un test pour résoudre les problèmes de passages de tableaux de structure et je n'ai pas encore implémenté tout les vérifications après exécution des instructions. En particulier je n'ai pas encore vérifié si mon programme fonctionnait lorsque j'insère à la première position (mais cela va venir).

      Quoi qu'il en soit, merci beaucoup pour ces conseils avisés et très utiles.

  13. #13
    Membre Expert
    Avatar de Metalman
    Homme Profil pro
    Enseignant-Chercheur
    Inscrit en
    Juin 2005
    Messages
    1 049
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Enseignant-Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 1 049
    Par défaut
    Pour le C++ : il a dit "compiler" !
    Visual Studio compile en C++ par défaut.
    Le C passe sans problème dans un compilo C++, mais pas l'inverse évidemment...
    Niveau mémoire, pointeur etc... c'est quasiment la même chose C et C++...
    Et les C/C++ sont "aussi" portables si tu recompiles en respectant strictement la norme.... (moins quelques divergences variées)

    Même si le type "bool" est dispo en C99, il ne l'est pas en C89, et ça "arrive" que cela bloque certains compilos, mais dans ton cas non ! Donc tant mieux !
    Surtout que C99 est utilisé par défaut "en général".

    Pour les mallocs non-free : certes si ton programmes ne reste pas longtemps en mémoire, et que tu limites le nombre de mallocs... c'est tolérable... mais les mauvaises habitudes s'attrapent très très très vite !
    Et pour débugger, il est TRES conseillé de free, car certains outils te diront que tu re-écris par dessus un espace précédemment libéré (donc plus facile de voir quand est-ce que tu écrases une valeur sans raison).
    Si tu ne free pas, ils ne te diront pas que tu écris là où il ne faut pas (pointeur pas remis à NULL, etc...)
    --
    Metalman !

    Attendez 5 mins après mes posts... les EDIT vont vite avec moi...
    Les flags de la vie : gcc -W -Wall -Werror -ansi -pedantic mes_sources.c
    gcc -Wall -Wextra -Werror -std=c99 -pedantic mes_sources.c
    (ANSI retire quelques fonctions comme strdup...)
    L'outil de la vie : valgrind --show-reachable=yes --leak-check=full ./mon_programme
    Et s'assurer que la logique est bonne "aussi" !

    Ma page Developpez.net

  14. #14
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par GérardMartinelli Voir le message
    Avant de code l'instruction while (true), j'avais vérifié que cela était supporté depuis mai 2000 ( norme ISO/IEC 9899:1999 soit en court effectivement : C99). Je pense que depuis 13 ans, on a le droit d'utiliser cette "nouvelle" norme.
    Tu tout à fait les droit de l'utiliser, mais il te manque pour cela l'entête sans quoi tu obtiendrais une erreur "undefined". Et c'est qui me fais penser que tu compiles (comme le souligne Metalman ) en C++.
    Dernière modification par Invité ; 07/05/2013 à 00h30. Motif: Petite erreur de personne

  15. #15
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2009
    Messages
    265
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2009
    Messages : 265
    Par défaut
    J'ai compris, en fait j'utilise un environnement de développement C-Free 5 (pas free du tout d'ailleurs) qui permet de compiler à la fois du C++ et du C. Ce qui explique sans doute pourquoi je n'ai pas eu besoin de #include stdbool car la compilation ne donne aucun message.

    Pour ce qui est de libérer la mémoire j'ai modifié mon code pour suivre vos conseils.

    Je crois que je peux maintenant clore ce fil mais sans vous avoir auparavant remercié encore une fois pour toute l'aide que vous m'avez apportée.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 4
    Dernier message: 08/11/2012, 15h11
  2. Réponses: 0
    Dernier message: 15/06/2010, 10h58
  3. Réponses: 6
    Dernier message: 28/12/2009, 16h45
  4. Réponses: 11
    Dernier message: 30/04/2008, 10h18
  5. passage d'un tableau structuré en parametre
    Par babou54 dans le forum Delphi
    Réponses: 11
    Dernier message: 18/05/2007, 12h15

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