lecture d'un fichier et traitement des données lues

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:

---

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:

---

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:

---

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

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

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

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

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

Citation:

---

Envoyé par m0ul3sh0t

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

Code:

---

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:

---

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

Citation:

---

Envoyé par m0ul3sh0t

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

Citation:

---

Envoyé par m0ul3sh0t

Code:

---

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

---

---

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

Citation:

---

Envoyé par m0ul3sh0t

Code:

---

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

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

Citation:

---

Envoyé par m0ul3sh0t

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

Citation:

---

Envoyé par Sve@r

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?

je le redis :

Citation:

---

Envoyé par nicolas.sitbon

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

---

Citation:

---

Envoyé par m0ul3sh0t

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:

---

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:

---

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

Citation:

---

Envoyé par Sve@r

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

Code:

---

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:

---

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:

---

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

---

C'est à dire respectivement :

Code:

---

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

---

et

Code:

---

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

---

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

Citation:

---

Envoyé par Emmanuel Delahaye

Code:

---

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

Citation:

---

Envoyé par Emmanuel Delahaye

Code:

---

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?

Citation:

---

Envoyé par m0ul3sh0t

ce n'est pas plutot:

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

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

---

Code:

---

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?

Citation:

---

Envoyé par m0ul3sh0t

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:

---

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.

Citation:

---

Envoyé par m0ul3sh0t

ce n'est pas plutot:

Code:

---

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

---

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

---

Non la formule, c'est :

Code:

---

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

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

Citation:

---

Envoyé par 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))

---

Non. Tout cela est faux.

Citation:

---

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.

Citation:

---

Tu me dis que T est un char *

---

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

Code:

---

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

---

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

Citation:

---

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:

---

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

---

Code:

---

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

Citation:

---

Envoyé par m0ul3sh0t

Code:

---

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

---

Il est techniquement possible de séparer les instructions, mais je trouve plus clair (et plus sûr) de les regrouper quand c'est possible.

Citation:

---

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

---

On alloue rien du tout à tab...

malloc() demande au système d'allouer un bloc d'une certaine taille, si l'allocation est possible, l'adresse du début du bloc est retournée.

Pour des raisons évidentes d'utilisation par la suite, cette adresse est stockée. Evidemment, on utilise un pointeur (un pointeur, c'est fait pour stocker une adresse) et on le définit du même type, ce qui permet son usage.

Donc, si je veux créer une variable de type T :

1 - je définis un pointeur de type T :

T *p

2 - je demande l'allocation d'un bloc de type T

malloc(sizeof (T))
ou
malloc(sizeof *p)

3 - je stocke l'adresse :

p = malloc(...)

Ce que je fais en une opération :

Code:

---

T *p = malloc(sizeof *p);

---

évidemment, malloc() pouvant échouer, on ne fera rien sans avoir testé la valeur de l'adresse retournée :

Code:

---

1 2 3 4 5

T *p = malloc(sizeof *p); if (p != NULL) { /* utilisation */

---

et bien sûr, quand c'est terminé, je libère le bloc alloué :

free (p);

et je force le pointeur à NULL pour bien signifier qu'il est invalide

p = NULL;

ce que je recommande de faire comme ceci :

Code:

---

1 2 3 4 5 6 7 8 9 10

T *p = malloc(sizeof *p); if (p != NULL) { /* utilisation */     /* fin */ free (p), p = NULL; }

---

Pour créer un tableau, on multiplie la taille demandée par le nombre d'éléments :

Code:

---

1 2 3 4 5 6 7 8 9 10

T *p = malloc(sizeof *p * n); if (p != NULL) { /* utilisation */     /* fin */ free (p), p = NULL; }

---

Nota : T représente le type de l'utilisateur.