Discussion :

[shmeta]

bonjour

je voudrais savoir comment on peut faire pour qu'une fonction en C retourne un tableau de reel ???

j'ai une fonction du genre

Code :

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

void recup_data_one_date(float output_coor[nbligne][nbcolonne],int date1,int date2,int part_time)

je voudrais modifier cette fonction , en lui donnant le nbligne et nbcolonne et elle retourne la matrice output_coor donc ma fonction ressemblera à ça

Code :

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

void recup_data_one_date(int date1,int date2,int part_time,int nbligne, int nbcolonne)

[ram-0000]

Un truc dans ce genre ?

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
float *recup_data_one_date(int date1,int date2,int part_time,int nbligne, int nbcolonne)
{
float *tbl = malloc(sizeof(float) * nbligne * nbcolonne);
   if(tbl == NULL)
   {
      // erreur d'allocation mémoire
      return NULL;
   }
 
   // initialisation du tableau
...
 
   // retourne le tableau alloué
   // ne pas oublier de le liberer avec free() quand on n'en a plus besoin
   return tbl;
}

[shmeta]

merci bcp

donc je dois utiliser des pointeurs...

[souviron34]

• primo une fonction ne retourne pas un tableau.. Au mieux une adresse, une valeur, ou rien.
• secondo, il suffit de passer une adresse ou un tableau. Si l'allocation se fait dans le corps de la fonction, il faut passer une adresse modifiable (l'adresse d'une adresse). Si l'allocation est déjà faite avant d'appellet, il sufit de passer l'adresse.

[Gruik]

Salut

plutot un truc dans le genre?

Code :

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

float ** recup_data_one_date(int date1,int date2,int part_time,int nbligne, int nbcolonne);

Après l'appellant doit savoir qu'il ya tant de lignes et tant de colonnes et il devra se débrouiller pour libérer chaque ligne

[diogene]

Et pour compléter ram-0000 et Gruik, consulte la FAQ Comment allouer dynamiquement un tableau à 2 dimensions ?

[shmeta]

là je suis un peu perdu

est ce que je dois faire

Code :

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

float ** recup_data_one_date(int date1,int date2,int part_time,int nbligne, int nbcolonne);

ou bien

Code :

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

float *recup_data_one_date(int date1,int date2,int part_time,int nbligne, int nbcolonne

et un autre truc , comment faire pour accéder par exemple la ligne 3 colonne 3 ???

[diogene]

Si tu veux pouvoir écrire tab[3][3], utilise la première solution et consulte la FAQ.

Code :

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

float ** tab =  recup_data_one_date(.....)

Par contre, la libération de la mémoire allouée sera un peu plus compliquée que dans la seconde possibilité.

Si tu utilises la seconde solution,

Code :

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

float * tab = recup_data_one_date(.....)

tu devras calculer la position des éléments dans un tableau équivalent à une dimension, ce qui est assez peu commode et tu ne pourras pas écrire tab[3][3] mais tab[3*...+3] (... est nbligne ou nbcolonne selon la manière dont la fonction a été écrite).

[shmeta]

salut j'ai préféré la deuxiéme solution puisque c'est la plus facile

voilà mon code qui permet de lire une matrice à partir d'un fichier texte

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
 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h> 
 
 
int nb_lignes (FILE *fp)
{
  int n=0, c;
 
  while ((c = fgetc(fp)) != EOF)
  {
    if (c == '\n')
    {
      n++;
    }
 
  }
  return n;
}
 
unsigned long file_how_much_word (FILE *p_file)
{
 
   long   cnt_w  = 0;
 
 
 
 
 
      if (p_file != NULL)
      {
         int c = 0;
         int mark = 0;
 
 
         while ((c = fgetc (p_file)) != EOF)
         {
            if (! isspace (c) && mark == 0)
            {
               cnt_w++;
               mark = 1;
            }
            else if (isspace (c))
            {
               mark = 0;
            }
         }  
 
         fclose (p_file);
      }
 
 
 
   return cnt_w;
}
float *lire_matrice(char chemin[100])
{	
	int nbligne, nbcolonne,i,j;
	unsigned long nbmots;
 
 
	FILE *ReadInput;
 
	ReadInput = fopen (chemin, "r" ) ;
 
	if(ReadInput == NULL)
	{
	printf("Le fichier des coordonnées NARR n'existe pas");
	} 
 
	else
	{
		nbligne= nb_lignes(ReadInput);
		nbmots = file_how_much_word (ReadInput);
		nbcolonne = nbmots/nbligne;
		fclose(ReadInput);
 
	}
 
	float *tbl = malloc(sizeof(float) * nbligne * nbcolonne);
 
	ReadInput = fopen (chemin, "r" ) ;
	if(ReadInput == NULL)
	{
	printf("Le fichier des coordonnées NARR n'existe pas");
	} 
	else
	{
 
 
   	for (i=0;i<nbligne;i++)
 
	{
		for (j=0;j<nbcolonne;j++)
		{
 
			fscanf(ReadInput,"%f ",tbl);
 
		}
		fscanf(ReadInput,"\n");
 
	}	
 
 	}
 
 
 
 // initialisation du tableau
 
   // retourne le tableau alloué
   // ne pas oublier de le liberer avec free() quand on n'en a plus besoin
   return tbl;
}
 
 
int main(int argc, char *argv[])
 
{	
 
 
	float *tbl;
 
 
	tbl = lire_matrice(argv[1]);
 
return 1; 
 
 
 
}

quand je compile tous marche bien et lors de l'éxécution il me sort un truc

du genre

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
 
./test.o point-narr-H-narr_84pts.txt 
*** glibc detected *** ./test.o: double free or corruption (top): 0x0000000009a36010 ***
======= Backtrace: =========
/lib64/libc.so.6[0x36e8671834]
/lib64/libc.so.6(cfree+0x8c)[0x36e8674e7c]
/lib64/libc.so.6(fclose+0x14b)[0x36e866089b]
./test.o[0x400777]
./test.o[0x40083a]
/lib64/libc.so.6(__libc_start_main+0xf4)[0x36e861d8b4]
./test.o[0x400599]
======= Memory map: ========
00400000-00401000 r-xp 00000000 08:21 71008518                           /lgit/baltih/Desktop/version2/test.o
00600000-00601000 rw-p 00000000 08:21 71008518                           /lgit/baltih/Desktop/version2/test.o
09a36000-09a57000 rw-p 09a36000 00:00 0 
36e7600000-36e761a000 r-xp 00000000 08:01 3417125                        /lib64/ld-2.5.so
36e781a000-36e781b000 r--p 0001a000 08:01 3417125                        /lib64/ld-2.5.so
36e781b000-36e781c000 rw-p 0001b000 08:01 3417125                        /lib64/ld-2.5.so
36e8600000-36e874a000 r-xp 00000000 08:01 3417132                        /lib64/libc-2.5.so
36e874a000-36e894a000 ---p 0014a000 08:01 3417132                        /lib64/libc-2.5.so
36e894a000-36e894e000 r--p 0014a000 08:01 3417132                        /lib64/libc-2.5.so
36e894e000-36e894f000 rw-p 0014e000 08:01 3417132                        /lib64/libc-2.5.so
36e894f000-36e8954000 rw-p 36e894f000 00:00 0 
36ed200000-36ed20d000 r-xp 00000000 08:01 3417146                        /lib64/libgcc_s-4.1.2-20080102.so.1
36ed20d000-36ed40d000 ---p 0000d000 08:01 3417146                        /lib64/libgcc_s-4.1.2-20080102.so.1
36ed40d000-36ed40e000 rw-p 0000d000 08:01 3417146                        /lib64/libgcc_s-4.1.2-20080102.so.1
2b20da944000-2b20da945000 rw-p 2b20da944000 00:00 0 
2b20da96b000-2b20da96d000 rw-p 2b20da96b000 00:00 0 
2b20dc000000-2b20dc021000 rw-p 2b20dc000000 00:00 0 
2b20dc021000-2b20e0000000 ---p 2b20dc021000 00:00 0 
7fffd0150000-7fffd0166000 rw-p 7fffd0150000 00:00 0                      [stack]
ffffffffff600000-ffffffffffe00000 ---p 00000000 00:00 0                  [vdso]
Aborted

je ne suis pas un pro de C et moins encore des pointeurs du coup je ne sais pas le problème ???

[diogene]

Deux erreurs (au moins)
- la première provoque probablement l'erreur à l'exécution signalée :

Code :

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

1
2
3
4
5
		nbligne= nb_lignes(ReadInput);
		nbmots = file_how_much_word (ReadInput);
		nbcolonne = nbmots/nbligne;
.....
                float *tbl = malloc(sizeof(float) * nbligne * nbcolonne);

La fonction nb_lignes lit tout le fichier. En sortie, on est à la fin du fichier et la fonction file_how_much_word renvoie donc 0. La demande d'allocation sera de 0 float.

- la seconde est ici :

Code :

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

fscanf(ReadInput,"%f ",tbl);

On écrit toujours au même endroit (le premier élément du tableau)

- Pour charger la matrice ainsi construite, le nombre de lignes et de colonnes est sans importance. Seul le nombre de mots importe.

- Par ailleurs, la fonction est très mal construite : elle renvoie un tableau dont les dimensions sont inconnues. Le programme appelant ne va tout de même pas recommencer à relire deux fois caractères par caractères le fichier pour les déterminer à nouveau. De même l'utilisation de deux fonctions pour déterminer le nombre de lignes et le nombre de mots implique de le parcourir deux fois alors qu'on peut faire les deux choses en même temps. Si le fichier est gros, cela va finir par être pénalisant.

[Copolla]

Une fonction ne retourne jamais un tableau ...

[souviron34]

Une fonction ne retourne jamais un tableau ...

mais une adresse peut référer à un tableau

[shmeta]

et donc ??? comment je peux la corriger ???

[Obsidian]

• primo une fonction ne retourne pas un tableau.. Au mieux une adresse, une valeur, ou rien.

Il faut ajouter également : une structure ! Et celle-ci peut contenir un tableau de taille fixe et connue à l'avance. Au point de vue syntaxe, il faut à chaque fois accéder à son unique membre pour se référer à ce tableau, et ce n'est de toutes façons pas un exemple à donner. Par contre, au point de vue manipulation, cela permet de le transmettre en retour de fonction et de le dupliquer avec « = » sans avoir recours à memcpy() ou à une autre fonction.

[Gruik]

ou encore un type abstrait manipulé uniquement par un pointeur et des fonctions

[souviron34]

Il faut ajouter également : une structure ! Et celle-ci peut contenir un tableau de taille fixe et connue à l'avance. Au point de vue syntaxe, il faut à chaque fois accéder à son unique membre pour se référer à ce tableau, et ce n'est de toutes façons pas un exemple à donner. Par contre, au point de vue manipulation, cela permet de le transmettre en retour de fonction et de le dupliquer avec « = » sans avoir recours à memcpy() ou à une autre fonction.

une adresse de structure

[diogene]

une adresse de structure

Non, Obsidian parle bien de retourner une structure, ce qui est tout à fait possible même si ce n'est pas souhaitable si la structure est grosse.