Discussion :

[GérardMartinelli]

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]

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]

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]

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

[imperio]

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

[GérardMartinelli]

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