Passage d'un tableau de structure

**GérardMartinelli** · 01/05/2013, 15h00

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
}

**Metalman** · 01/05/2013, 15h16

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...

**Bktero** · 01/05/2013, 16h04

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/

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return Nouveau;

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.

**GérardMartinelli** · 02/05/2013, 23h24

Merci à tous pour vos réponses qui me sont très utiles

**imperio** · 03/05/2013, 08h04

Sinon tu peux toujours faire une structure qui contiendra ton tableau ainsi que sa taille.

**GérardMartinelli** · 04/05/2013, 18h41

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;
}

**Flodelarab** · 04/05/2013, 19h34

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

Invité · 04/05/2013, 19h41

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 :

Un premier niveau en déclarant un élément :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

struct monElement x0 = {"Durand", "Pierre", 42};

Puis le tableau des 5 éléments comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
monElement Ancien[5] = {  
    {"Durand", "Pierre", 42},
    {"Martin", "Jean", 17},
    {"Poquelin", "Jean-Baptistet", 62},
    {"Camus", "Albert", 38}, 
    {"Dupont", "Robert", 20}
};

É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().)

**GérardMartinelli** · 05/05/2013, 18h01

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));
}

Invité · 05/05/2013, 19h15

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 ?

**Bktero** · 06/05/2013, 09h44

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 ^^

**GérardMartinelli** · 06/05/2013, 11h54

Envoyé par Winjerome

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.

**Metalman** · 06/05/2013, 13h12

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...)

Invité · 06/05/2013, 13h46

Envoyé par GérardMartinelli

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#include <stdbool.h>

sans quoi tu obtiendrais une erreur "undefined". Et c'est qui me fais penser que tu compiles (comme le souligne Metalman

) en C++.

**GérardMartinelli** · 07/05/2013, 08h06

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.

Passage d'un tableau de structure

C

Discussions similaires

Partager

Partager