Discussion :

[nesrine6215]

bonjour,
je suis debutante en langage c.et je dois ecrire un programme qui permet de stocker un fichier d'une taille variable dans un tableau dynamique.
mon idée est de
1. calculer la taille du fichier : le nombre de ses caractères par la fonction nbcaractere()
2.creer un tableau dynamique qui a comme taille le nombre des caractère de fichier :la fonction convert() va retouner ce tableau de caractère .mais comment recuperer ce tableau dans le main et l'afficher:qlq'un pourra m'aider svp je dois rendre cette exercice deamin merci.voici mon programme :

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int nbcaratere(void);
int main()
{
int i,n;
n=nbcaratere();
char c;
printf("la taille est de %d",n);
for(i=0;i<n;i++)
{
c=convert();
printf("%c",c);
}
return 0;
}
 
int nbcaratere(void)
{
FILE *f;
f = fopen("c:\\t.txt", "r");
if (f == NULL) /* ´equivalent `a << if (!f) >> */
{
printf("Erreur lors de l’ouverture du fichier!\n");
}
else
{
int fin;
fseek(f, 0, SEEK_END);
fin = ftell(f);
//printf("Le fichier a une longueur de %i\n", fin);
fseek(f, 0, SEEK_SET);
fclose(f);
return (fin);
}
 
}
 
 char convert(void)
{
FILE *f;
 
int i,n, c;
char *e;
n=nbcaratere();
e=(char*)malloc(n*sizeof(char));
 
f = fopen("c:\\t.txt", "r");
if (f == NULL) 
{
printf("Erreur lors de l’ouverture du fichier!\n");
}
else
{
do {
 
            c = fgetc (f);
           e[i]=c; 
 
printf("le caractère est %c",e[i]);
 
 
        } while (c != EOF);
 
}
fclose(f);
return *e;
free (e);
 
 }

[AjJi]

Ta fonction convert devra tout simplement retourner un char* au lieu de char, et dans ton main, tu fais quelque chose du genre:

Code :

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

1
2
3
4
 
char *T;
T = (char*)malloc((taille_du_fichier)*sizeof(char));
T = convert();

Normalement, cela devrait marcher.

[Trap D]

Ben non, là, tu as une superbe fuite mémoire puisque l'adresse qui vient d'être fournie par le malloc est perdue !

[nicolas.sitbon]

Ta fonction convert devra tout simplement retourner un char* au lieu de char, et dans ton main, tu fais quelque chose du genre:

Code :

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

1
2
3
4
 
char *T;
T = (char*)malloc((taille_du_fichier)*sizeof(char));
T = convert();

Normalement, cela devrait marcher.

le cast du retour de malloc est inutile, qui plus est, sizeof (char) vaut toujours 1.
2 possibilités :

Code :

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

char *T = malloc (taille_du_fichier);

soit, si on veut se préparer au passage à l'unicode :

Code :

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

char *T = malloc(taille_du_fichier * sizeof *T);

[dj.motte]

Salut,

Autant lire d'un trait le fichier.
Par ex avec une fonction:

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
 
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
 
char * read_the_file( const char * fname )
{
   size_t r ;
   char* z = NULL  ;
   FILE * fd = NULL;
 
   struct stat st ;
 
   fd = fopen ( fname , "rb");
   if (fd == NULL)
   { perror ( fname );
     return NULL ;
   }
 
   if( stat( fname, &st ) != 0  )
   {
     perror("erreur dans stat\n") ;
     return NULL ;
   }
 
   z = (char*) malloc( (st.st_size + 1)  * sizeof(char) ) ;
   if( !z  ) return NULL  ;
 
   r = fread( z , sizeof( char ), st.st_size, fd ) ;
   if( r == (size_t) st.st_size )
   { 
      *( z + st.st_size ) = '\0' ;
 
   }
   else
   {
     printf("Impossible de lire %s\n", fname ) ;
     free( z ) ;
     z = NULL ;
   }
 
   if( fd ) fclose(fd) ;
 
   return  z ;
}
 
int main()
{ 
  char * z = read_the_file( "toto.txt" ) ;
  if ( z ) ....
}

[Emmanuel Delahaye]

Autant lire d'un trait le fichier.
Par ex avec une fonction:

Code :

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

1
2
3
4
 
#include <unistd.h>
<...>
   struct stat st ;

Pas standard... De plus, faire un stat() sur un fichier ouvert est une drôle d'idée... Je dirais comportement indéfini, mais je n'ai pas le temps de lire la doc de stat en détail...

fseek()/ftell()/rewind() devrait suffire ...

Code :

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

   z = (char *) malloc ((st.st_size + 1) * sizeof (char));

A quoi sert le cast ?
A quoi sert sizeof (char) alors qu'il vaut 1 par définition ?

Pourquoi écrire du code plus compliqué que nécessaire :

Code :

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

   z = malloc (st.st_size + 1);

Tout simplement...

Par contre, attention à ne pas tomber dans la simplification extrême qui fait faire des âneries :

Code :

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

1
2
3
 
   if (!z)
      return NULL;

le fichier n'est pas refermé...

D'autre part, !z, bien que techniquement correct est peu lisible. Déjà, z est un curieux nom de pointeur. D'autre part, s'agissant d'un pointeur, z == NULL est plus approprié, même si c'est un peu plus long à écrire. Toujours privilégier la relecture du code. Ne pas présumer du niveau de geekness du lecteur potentiel...

Code :

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

      *(z + st.st_size) = '\0';

Techniquement correct, mais inutilement complexe.

Code :

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

      z[st.st_size] = '\0';

ou encore

Code :

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

      z[st.st_size] = 0;

Je propose ceci :

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
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
char *read_the_file (const char *fname)
{
   char *z = NULL;
   FILE *fp = fopen (fname, "rb");
   if (fp != NULL)
   {
      unsigned long len;
      fseek (fp, 0, SEEK_END);
      len = ftell (fp);
      rewind (fp);
 
      printf ("len = %lu\n", len);
      if (len <= ((size_t) - 1))
      {
         z = malloc (len + 1);
         if (z != NULL)
         {
            if (len == fread (z, 1, len, fp))
            {
               z[len] = 0;
            }
            else
            {
               printf ("Impossible de lire %s\n", fname);
               free (z), z = NULL;
            }
         }
      }
      else
      {
         printf ("the file is too big\n");
      }
      fclose (fp);
   }
   else
   {
      perror (fname);
   }
   return z;
}
 
int main (void)
{
   char *z = read_the_file ("main.c");
   if (z != NULL)
   {
      puts (z);
      free (z);
   }
   return 0;
}

[orfix]

Salut,

J'ai une toute petite question que signifie cette ligne :

Code :

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

1
2
 
if (len <= ((size_t) - 1))

Si len est inférieur ou égale à la plus grande valeur que peut prendre une variable de type size_t moins un ...???

Petite remarque il faut peut être un :
#include <stdlib.h> /* malloc / free */


@++

[Emmanuel Delahaye]

J'ai une toute petite question que signifie cette ligne :

Code :

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

1
2
 
if (len <= ((size_t) - 1))

Si len est inférieur ou égale à la plus grande valeur que peut prendre une variable de type size_t moins un ...???

Oui, c'est presque ça. En fait, (T)-1 représente la plus grande valeur possible d'un type quand celui-ci est non signé (un size_t est un entier non signé). Je crois qu'en C99, il y a une constante pour size_t dans <limits.h> (SIZE_MAX ou SIZE_T_MAX)...

Petite remarque il faut peut être un :
#include <stdlib.h> /* malloc / free */

Oui, merci, c'est corrigé.

[nicolas.sitbon]

Je crois qu'en C99, il y a une constante pour size_t dans <limits.h> (SIZE_MAX ou SIZE_T_MAX)...

limit of size_t
SIZE_MAX 65535

SIZE_MAX est définie dans stdint.h.
Cordialement.

[Médinoc]

Et visual C++ supporte aussi SIZE_MAX, bien qu'il ne supporte pas C99.

[dj.motte]

Salut,

unistd.h pas standard. Pourtant on s'en sert souvent dans le monde de Linux.

Avec Windows est-ce que io.h peut proposer des services équivalents à unistd.h ? Je pose la question car je ne me sers jamais du Visual C de Microsoft.

[Emmanuel Delahaye]

unistd.h pas standard. Pourtant on s'en sert souvent dans le monde de Linux.

Et ?

Avec Windows est-ce que io.h peut proposer des services équivalents à unistd.h ? Je pose la question car je ne me sers jamais du Visual C de Microsoft.

Moi non plus, donc, aucune idée...

[dj.motte]

Salut,

Au sujet de unistd.h , Mr Delahaye écrit :

De plus, faire un stat() sur un fichier ouvert est une drôle d'idée... Je dirais comportement indéfini, mais je n'ai pas le temps de lire la doc de stat en détail...

C'est une remarque pertinente. Certaines opérations demandent que les fichiers soient ouverts, d'autres non.

( chsize, fchsize, truncate, ftruncate, stat, fstat, rename...etc).

Pour un fichier ouvert avec fopen, c'est fstat de unistd.h, dont on peut se servir avec linux.

[nicolas.sitbon]

De plus, faire un stat() sur un fichier ouvert est une drôle d'idée... Je dirais comportement indéfini, mais je n'ai pas le temps de lire la doc de stat en détail...

Non non, de ce côté là, pas de problème, heureusement d'ailleurs, comment vérifier sinon qu'un utilisateur n'a pas déjà ouvert un fichier avant nous? Au niveau de de la norme, aucun soucis!

[Médinoc]

unistd.h n'est peut-être pas standard, mais si je ne me trompe, c'est POSIX. Comme Linux respecte aussi la norme POSIX (du moins en grande partie), unistd.h sera toujours disponible sous linux...

[nicolas.sitbon]

unistd.h n'est peut-être pas standard, mais si je ne me trompe, c'est POSIX. Comme Linux respecte aussi la norme POSIX (du moins en grande partie), unistd.h sera toujours disponible sous linux...

Je confirme, unistd.h est standard POSIX, donc très portable :
http://www.opengroup.org/onlinepubs/.../unistd.h.html

[Klaine]

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
#include<stdio.h>
#include<stdlib.h>
void stockage_dans_tableau(char *tableau,FILE * flux,unsigned taille)
{
     int k;
     int c;
     int i=0;
     do{
         c=fgetc(flux);
     if(k=!feof(flux))
     {
     tableau[i]=c;
     i++;
     }
     }while(k);
     printf("\n");
     fclose(flux);
}
int nb_caractere(FILE * flux)
{
    int k;
    int c=0; 
    unsigned o=0;
 
 
 
do
{
        c=fgetc(flux);
if(k=!feof(flux))
    {
    o++;
    }
}while(k);
fclose(flux);
return o;
}
int main(void)
{
    int nb=0;
    char *tableau;
    FILE *flux;
    char nom[1024];
    int i=0;
    printf("Entrez le nom du fichier : ");
    scanf("%s",nom);
        flux=fopen(nom,"r");
nb=nb_caractere(flux);
printf("il y a %d caracteres.\n",nb);
 
tableau=calloc(nb+1,sizeof(char));
if(tableau!=NULL)printf("bien alloue.\n");
else printf("pas allloue.\n");
 flux=fopen(nom,"r");
stockage_dans_tableau(tableau,flux,nb);
 
for(i=0;i<nb;i++)
{
printf("%c",tableau[i]);
}
 
printf("\n\n");
 
free(tableau);
//system("pause");
return 0;
}

certaine phrase du code peuvent etre facilement changee