Discussion :

[m0ul3sh0t]

Bonsoir à tous,

je viens faire appel à vous parce que j'ai encore un petit souci.
Je dois lire un fichier qu'on nous passe en paramètre.
J'ouvre d'abord ce fichier avec la fonction open qui nous renvoie un entier (file descriptor).

Code :

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

fd = open(argv[i], O_RDONLY);

Après avoir tester la valeur du fd, pour être sur qu'il n'y ait pas eut de problème. Dans le cas où l'ouverture s'est faite sans aucun problème, je renvoie mon fd pour une lecture du fichier.

Code :

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

byte_read = read(fd, buffer, BUFFER_SIZE);

La fonction read renvoie un entier qui représente le nombre d'octet lu, et BUFFER_SIZE est le nombre d'octet à lire. (si j'ai fait une erreur dites le moi svp ).
Ce que je souhaite faire c'est copier ce que je lis dans une chaine de caractère (donc un char *) ou une tableau de chaîne de caractère (donc un char **). J'hésite entre les deux parce que le fichier comporte plusieurs lignes.
Je pensais représenter le truc comme ca:

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
int   byte_read;
  int   x;
  int   y;
  char  buffer[BUFFER_SIZE];
  char  **chaine;
 
  x = 0;
  y = 0;
  byte_read = 1;
  chaine = malloc(sizeof(**chaine));
  while (byte_read != 0)
    {
      while (buffer !=  ?)
        {
          while (buffer != '\n')
            {
              byte_read = read(fd, buffer, BUFFER_SIZE);
              if (byte_read == -1)
                return (-1);
              chaine[y][x] == buffer;
              y++;
            }
          x++;
        }
    }

Je pensais lire le fichier tant que le buffer n'a pas atteint la fin de la ligne (du fichier) c'est-à-dire '\n' et ceux tant que je n'ai pas atteinds la dernière ligne, et bien sur à chaque ligne je copie ce que j'ai lu.
x représente le caractère dans la ligne et y le "numéro" de ligne.
Le code est ma vision mais malheuresement comme ceci je n'arrive pas à faire ce que je veux et je commence à avoir des doutes sur la façon dont j'ai codé.
Si quelqu'un veut bien me donner un indice d'où est l'erreur

[nicolas.sitbon]

un petit tour ici ne te fera pas de mal : http://emmanuel-delahaye.developpez.....htm#tabdyn_2d
Cordialement.

[m0ul3sh0t]

le problème est que je ne peux pas connaitre à l'avance le nombre de colonne M et le nombre de lignes N
le fichier que je dois lire et reutiliser a une taille variable, d'où mon problème en fait

[ram-0000]

Peut être que tu peux récupérer la taille de ton fichier une fois que l'ouverture est faite pour allouer ton buffer

stat() ou fstat() sont tes amies

[m0ul3sh0t]

le problème est que je ne peux pas utiliser des fonction système à moins de le recoder moi même
je pensais que ma façon de faire me permettrait de "copier" ce qui est lu dans un char * voir un char ** mais au vu des réponses, j'en suis de moins en moins convaincu

[Sve@r]

J'ouvre d'abord ce fichier avec la fonction open qui nous renvoie un entier (file descriptor).

Code :

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

fd = open(argv[i], O_RDONLY);

Après avoir tester la valeur du fd, pour être sur qu'il n'y ait pas eut de problème. Dans le cas où l'ouverture s'est faite sans aucun problème, je renvoie mon fd pour une lecture du fichier.

Code :

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

byte_read = read(fd, buffer, BUFFER_SIZE);

La fonction read renvoie un entier qui représente le nombre d'octet lu, et BUFFER_SIZE est le nombre d'octet à lire. (si j'ai fait une erreur dites le moi svp ).

Jusque là ça va

Ce que je souhaite faire c'est copier ce que je lis dans une chaine de caractère (donc un char *) ou une tableau de chaîne de caractère (donc un char **). J'hésite entre les deux parce que le fichier comporte plusieurs lignes.

Tout dépend de ton besoin. Si tu veux
- lire une ligne
- traiter la ligne
- passer à la ligne suivante
alors c'est un char*

Si tu veux stocker tout le fichier, c'est alors un tableau de lignes où chaque ligne est un tableau de char d'où un char**

Code :

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

  chaine = malloc(sizeof(**chaine));

Pb: **chaine est un char donc t'alloues de la place pour un char

Code :

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

1
2
3
4
chaine[y][x] == buffer;
              y++;
            }
          x++;

Alors si "x" est le n° de la ligne et "y" le n° de colonne faut écrire chaine[x][y] pour être plus logique. Le problème c'est que tu traites chaine comme un tableau à 2d alors que tu lui as alloué de l'espace que pour un seul octet. Si vraiment tu veux faire comme ça, faut partir dans les boucles de malloc et de realloc selon l'algo suivant
1) a chaque nouvelle ligne, si le nb de lignes dépasse le nb de pointeurs alloués faut réallouer un nb "x" pour stocker les pointeurs sur les nouvelles lignes
2) chaque ligne, faut allouer un tableau de char que tu stockes dans un des pointeurs alloués en 1
3) stocker la ligne lue

Maintenant, si tu dois travailler en termes de "lignes", je te conseillerais d'utiliser fopen + fgets (ou fopen + getline) plus souple que open + read

[m0ul3sh0t]

je ne peux pas travailler ligne par ligne
je m'explique. Le sujet que je dois faire est: on a un "plateau" de jeu avec des cases et des obstacles. Le but est de créer le plus grand carré possible entre les obstacles.

Je pensais à un tab[y][x] pour que le x permettent de se déplacer dans la ligne et y dans le numéro de ligne
J'ai dit une connerie avant, le nombre de ligne nous est donné dans notre fichier à lire (c'est le premier charactère lu)

je vais me pencher sur ce que tu m'as dit et voir ce que j'arrive à faire

[Sve@r]

J'ai dit une connerie avant, le nombre de ligne nous est donné dans notre fichier à lire (c'est le premier charactère lu)

Alors t'as pas besoin de realloc. Tu alloues d'un coup autant de lignes que t'as besoin...

[m0ul3sh0t]

Alors t'as pas besoin de realloc. Tu alloues d'un coup autant de lignes que t'as besoin...

mais pour le malloc, tu donnes le nombre de caractères * sizeof(type du caractère) non?

[nicolas.sitbon]

je le redis :

un petit tour ici ne te fera pas de mal : http://emmanuel-delahaye.developpez.....htm#tabdyn_2d
Cordialement.

[Sve@r]

mais pour le malloc, tu donnes le nombre de caractères * sizeof(type du caractère) non?

Non. Lorsque tu alloues la mémoire tu dis "j'alloue n éléments" (quel que soit "element")

Code :

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

element *zone=malloc(n * sizeof(element))

Une ligne c'est un tableau de caractères donc char *ligne
Toi tu veux gérer un ensemble de "n" lignes donc

Code :

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

char **tabLig=malloc(n * sizeof(char *))

Là, tu te retrouves avec "n" pointeurs ("n" char*) et chaque pointeur, s'il est lui-même correctement alloué, peut stocker une ligne...

[Emmanuel Delahaye]

Non. Lorsque tu alloues la mémoire tu dis "j'alloue n éléments" (quel que soit "element")

Code :

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

element *zone=malloc(n * sizeof(element))

Une ligne c'est un tableau de caractères donc char *ligne
Toi tu veux gérer un ensemble de "n" lignes donc

Code :

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

char **tabLig=malloc(n * sizeof(char *))

Là, tu te retrouves avec "n" pointeurs ("n" char*) et chaque pointeur peut stocker une ligne...

C'est bien compliqué tout ça. Le mieux est s'en tenir à la forme canonique :

Code :

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

   T *p = malloc(n * sizeof *p);

C'est à dire respectivement :

Code :

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

element *zone = malloc (n * sizeof *zone)

et

Code :

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

char **tabLig = malloc(n * sizeof *tabLig)

ça évite de se planter dans les types et c'est auto-maintenable...

[Sve@r]

Code :

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

char **tabLig = malloc(n * sizeof *tabLig)

ça évite de se planter dans les types et c'est auto-maintenable...

Ouaip, c'est effectivement un raccourci plus sympa pour les habitués. Mais j'essayais d'être très basique pour qu'il comprenne bien la démarche...

[m0ul3sh0t]

Code :

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

char **tabLig = malloc(n * sizeof *tabLig)

ce n'est pas plutot:

char **tabLig = malloc(n * sizeof(**tabLig))

parce qu'on alloue n élément de type **tabLig non?

[m0ul3sh0t]

ce n'est pas plutot:

tabLig = malloc(n * sizeof(**tabLig))

parce qu'on alloue n élément de type **tabLig non?

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
  int   byte_read;
  int   i;
  char  buffer[BUFFER_SIZE];
  char  *tmp;
 
  i = 0;
  tmp = malloc(1024 * sizeof(*tmp));
  byte_read = 1;
  while (byte_read > 0)
    {
      byte_read = read(fd, buffer, BUFFER_SIZE);
      if (byte_read == -1)
        return (-1);
      while (buffer[i] != '\0')
        {
          tmp[i] = buffer[i];
          i++;
        }
    }
  my_putstr(tmp);

ce que j'ai fait c'est que j'ai créé un seul char * dans lequel je stock la totalité de ma lecture. Toutes les lignes ont une taille constante donc je pourrais recopier ma chaine dans une chaine temporaire en prenant comme limite le '\n' et du coup si je fais un my_strlen de ma chaine temporaire j'aurais la longueur de chaque ligne ce qui me permettra de boucler dessus jusqu'à la fin du fichier
est ce que je me trompe?

[Sve@r]

ce n'est pas plutot:

char **tabLig = malloc(n * sizeof(**tabLig))

parce qu'on alloue n élément de type **tabLig non?

Pas tout à fait. L'allocation d'un tableau en 2D (par exemple l lignes de c char donc un char**tab) se fait en 2 étapes
1) on alloue un tableau pour stocker les "l" lignes. Chaque ligne étant elle-même destinée à être plus tard un tableau, on alloue "l" pointeurs en 1D
donc tab=malloc(l * sizeof(char*)) ou tab=malloc(l * sizeof(*tab))
2) on balaye l'ensemble du tableau alloué et chaque pointeur est lui-même alloué pour stocker "c" char donc

Code :

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

1
2
3
4
5
6
for (i=0; i < l; i++)
{
    tab[i]=malloc(c * sizeof (char))
       // ou bien
    tab[i]=malloc(c * sizeof(**tab))
}

Puis on peut ensuite taper dans tab[x][y] à volonté
Si on veut travailler en 3D, 4D, 5D on étend le système (mais au delà de 3D cela devient ingérable donc on change de système de stockage (structures par exemple)

OU BIEN, toujours dans le cas du tableau 2D (l lignes de c char)
On alloue directement l * c char qui seront vus comme un gros tableau 1D
char *tab=malloc(l * c * sizeof(char))
Ensuite, si on veut taper dans "ce qui serait vu comme" l'élément tab[x][y], faut convertir ce système de coordonnés 2D (x, y) en 1D => tab[x][y] (2D) = tab[x * c + y] (1D)
Et on peut faire un calcul similaire pour passer de la 3D à la 1D etc...

Mais en aucun cas on passe directement du char** au char (d'ailleurs un char* * c'est fait pour stocker "n" char* et non "n" char.

[Emmanuel Delahaye]

ce n'est pas plutot:

Code :

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

char **tabLig = malloc(n * sizeof(**tabLig))

parce qu'on alloue n élément de type **tabLig non?

Non la formule, c'est :

Code :

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

   T *p = malloc(n * sizeof *p);

Il suffit de l'appliquer. Ici, T est char *.

**tabLig n'est pas un type, c'est un pointeur doublement déréférencé.

[m0ul3sh0t]

en fait je me suis trompé de bouton, au lieu de mettre éditer j'ai clické sur quoter.... :s

je pensais plutot à marquer comme ca:
tabLig = malloc(n * sizeof(**tabLig))

mais à voir ce que vous avez marqué je pense plutot à ça:
*tabLig = malloc(n * sizeof(**tabLig))


En fait j'ai du mal à comprendre la formule:
T *p = malloc(n * sizeof *p);
Tu me dis que T est un char * mais pour un malloc, je pensais qu'il fallait faire comme ca:
- on déclare notre variable : char *tab
- on alloue l'espace: tab = malloc (x * sizeof(*tab))
où x représente le nombre d'octet à allouer et le sizeof(*tab) le type à allouer donc dans ce cas c'est un char * et donc un octet

désolé j'ai un peu de mal à comprendre, ça fait que un mois que je "programme" :s

[Emmanuel Delahaye]

en fait je me suis trompé de bouton, au lieu de mettre éditer j'ai clické sur quoter.... :s

je pensais plutot à marquer comme ca:
tabLig = malloc(n * sizeof(**tabLig))

mais à voir ce que vous avez marqué je pense plutot à ça:
*tabLig = malloc(n * sizeof(**tabLig))

Non. Tout cela est faux.

En fait j'ai du mal à comprendre la formule:
T *p = malloc(n * sizeof *p);

Alors il faut commencer par là. Tant que tu n'a pas compris le principe, c'est pas la peine de continuer.

Tu me dis que T est un char *

Dans le cas présent, oui. Je rappelle le cas :

Code :

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

char **tabLig = malloc(...);

Le type de tabLig est char **, donc le type de *tabLig est char *.

mais pour un malloc, je pensais qu'il fallait faire comme ca:
- on déclare notre variable : char *tab
- on alloue l'espace: tab = malloc (x * sizeof(*tab))
où x représente le nombre d'octet à allouer et le sizeof(*tab) le type à allouer donc dans ce cas c'est un char * et donc un octet

C'est correct, sauf que les parenthèses sont inutiles :

Code :

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

   char *tab = malloc (x * sizeof *tab);

[m0ul3sh0t]

Code :

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

char *tab = malloc (x * sizeof *tab);

pour le cas d'un char * on m'avait expliqué qu'il fallait d'abord déclarer la variable (char *tab) et après faire l'allocation (tab = malloc(x * sizeof *tab))

Si j'ai bien comprit on alloue à tab x fois la taille du type char