Discussion :

[student_]

Bonsoir,

Je cherche a faire un petit programme qui fait un read sur l'entrée standard, récupère ce qu'on écrit dans un char *, jusqu'a tomber sur un '/n' (lorsqu'on appuie sur la touche entrée), et renvoie 0.

Seulement je veux faire quelque chose de dynamique, qui pourrait fonctionner avec un buffer d'une taille plus petite que la taille des arguments qu'on lui donne, en faisant plusieurs read, et pour se faire j'ai besoin de déclarer des static char*, et ca, je ne maitrise pas du tout...

Voici donc un code qui illustre comment je vois les choses (qui ne compile pas), merci pour vos explications !

.get_next_line.h
.get_next_line.c
.main.c

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
#ifndef         __GET_NEXT_LINE_H__
# define        __GET_NEXT_LINE_H__
 
#define BUFF_SIZE 1
 
typedef struct  s_test
{
static char     *result;
}               t_test;
 
int     get_next_line(const int fd, t_test *ptr);
void    my_putstr(char *str);
int     my_strlen(char *str);
 
#endif          /*__MY_GET_NEXT_LINE__ */

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
#include <stdlib.h>
#include <unistd.h>
#include "get_next_line.h"
 
void    my_malloc(static char *(*result), int debut, char *buffer, int fin)
{
  int   i;
 
  i = debut;
  while ((buffer[debut] != '\n') && (debut < fin))
    debut++;
  if (buffer[debut] == '\n')
    *result = malloc(((debut - i) + 1) * sizeof(*(*result)));
  else
    *result = malloc((debut - i) * sizeof(*(*result)));
}
 
 
int             get_next_line(const int fd, t_test *ptr)
{
  char          buffer[BUFF_SIZE];
  static int    debut = 0;
  static int    j = 0;
  static int    fin;
 
  if (debut == 0 || debut == fin)
    fin = read(fd, buffer, BUFF_SIZE);
  my_malloc(&(ptr->result), debut, buffer, fin);
  while ((buffer[debut] != '\n') && (debut < fin))
    {
      ptr->result[j] = buffer[debut];
      j++;
      debut++;
    }
  if (buffer[debut] == '\n')
    {
      ptr->result[j] = '\0';
 return (0);
    }
  else
    return (-1);
}

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
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include "get_next_line.h"
 
int     my_strlen(char *str)
{
  int   i;
 
  i = 0;
  while (str[i])
    i++;
  return (i);
}
 
void    my_putstr(char *str)
{
  write(1,str,my_strlen(str));
}
 
int             main()
{
  t_test        args;
 
  while (get_next_line(0, &args) != 0)
    get_next_line(0, &args);
  return (0);
}

[Pouet_forever]

Salut,

Je ne me suis pas penché complètement sur ton code mais j'ai déjà vu ça :

Code :

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

1
2
while (get_next_line(0, &args) != 0)
    get_next_line(0, &args);

Tu appelles 2 fois par boucle ta fonction get_next_line

Ensuite je voulais juste savoir pourquoi tu as absolument besoin des static ?
Sachant que tu utilises malloc je ne vois aucun intérêt à utiliser static.

Et puis read renvoie le nombre d'octets lus. Tu lis octet par octet et tu fais des mallocs à gogo, du coup tu fais de jolies fuites de mémoire
Tu peux allouer une grosse partie (je sais pas moi 512) et s'il reste des choses à lire tu ré-alloues 512 de plus etc. jusqu'à ce que tu lises tout.

[student_]

Salut !

Ok, je n'etais pas sur que les fonctions s'executaient de la meme maniere dans une condition de boucle, je vais donc uniquement dire:

Code :

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

while (get_next_line(0, &args) != 0)

Sinon, si je met 1 octet c'est pour tester que mon programme fonctionne, je compte par la suite lui donner au moins 1024 mais vue que je fais des tests sur l'entrée standard, je lui donne que 2 caractères pour tester si il boucle correctement.

Pourquoi déclarer un static ? Parce que je veux justement éviter de faire des malloc différents a chaque fois que je rappel ma fonction, mais "agrandir" le malloc de (ptr->result) a chaque appel de ma fonction, de la taille des nouveaux octets que read a pu stocker dans buffer, puis remplir ces nouveaux caracteres a la suite de ptr->result, et ce jusqu'à ce que j'atteigne le '/n'. C'est d'ailleurs mon problème, je ne sais pas comment faire et j'espère que le fait de déclarer un static char *result peut me permettre de faire ce genre d'algo dynamique selon la taille du buffer.

Pour résumer, mon but est simplement de read l'entrée standard en stockant tous les caractères dans un char *, et surtout, de faire en sorte a ce que ca fonctionne même si la taille du buffer nécessite de le faire en plusieurs read. Et enfin, que le processus s'arrête une fois arrive au '\n'.

[Pouet_forever]

Tu peux oublier tes static !
La fonction realloc fait ça très bien

[student_]

En t'expliquant mon code je me suis souvenu avoir vue ca quelque part "realloc", je vais voir le man !

Merci, bonne soirée !