Recoder la fonction getline

Version imprimable

Bonjour, j'essaye de re-coder la fonction getline et j'aimerais une petite aide à propos d'une partie... Quand j'appelle plusieurs fois ma fonction, mon fonction est lu sauf que si le read = 0 et que je continue à appeler ma fonction, mon programme segfault. Je ne vois pas comment faire ma condition me permettant de sortir de mon programme une fois que le programme a fini de lire toutes les lignes... Si quelqu'un pouvait me donner une idée, ça m'aiderait beaucoup, merci !

Le code :

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
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
 
char    *get_next_line(const int fd)
{
  static char   buffer[READ_SIZE];
  static int    i = 0;
  char          *str;
  int           j;
 
  j = 0;
  if ((str = malloc(sizeof(char) * READ_SIZE)) == NULL)
    return (NULL);
  if (read(fd, buffer, READ_SIZE) > 0)
    {
      while (1)
        {
          if (buffer[i] == '\n')
            {
              i++;
              return (str);
            }
          if (buffer[i] == '\0')
            {
              i = 0;
              str = my_realloc(str, READ_SIZE);
              if (read(fd, buffer, READ_SIZE) ==  0)
		{
                  if (str[0] != '\0')
                    return (str);
                  return (NULL);
		}
            }
          str[j] = buffer[i];
          j = j + 1;
          i = i + 1;
	}
      free(str);
    }
}
 
int     main(int argc, char **argv)
{
  int   fd;
  if (READ_SIZE == 0)
    return (-1);
  fd = open(argv[1], O_RDONLY);
  printf("%d\n", fd);
  printf("%s\n", get_next_line(fd));
  printf("%s\n", get_next_line(fd));
  printf("%s\n", get_next_line(fd));
}

13/01/2016, 06h51
Sve@r
Bonjour

Me semble que si tu arrives à la fin de ta fonction, faudrait quand-même lui faire renvoyer quelque chose non ???
Citation:
Envoyé par SBRKH

Code:

1 2 3 4 if (str[0] != '\0') return (str); return (NULL);
Bien que ce test s'écrive plus facilement return (str[0] != '\0') ?str :NULL;, je ne vois pas trop pourquoi tu renvoies NULL si ta chaine est vide. Une chaine vide reste une chaine, ce n'est pas NULL. De plus, tu cherches un '\0' dans une zone lue avec read() alors que read() ne te garantit pas qu'il te fournira une chaine donc pas forcément de '\0'...

Et ça me fait aussi penser que nulle part tu rajoutes de '\0' à ta zone renvoyée ce qui fait que dans ton main, t'as pas le droit de la lire avec "%s" (ce n'est pas une chaine)...
13/01/2016, 10h46
stendhal666
Ta signature pour getline() est différente de la fonction originale, qui retourne le nombre de caractères lus afin de dire au client si tu es arrivé à la fin du fichier. La signature de la fonction linux est:

Code:

ssize_t getline(char **lineptr, size_t *n, FILE *stream);

Donc tu renvoies quoiqu'il arrive le nombre de caractères lus (y compris le séparateur mais en excluant EOF) et l'appelant peut écrire:
Code:

1 2 3 4 while( getline(&mychaine, &already_allocated, stdin) ) { printf("La dernière ligne lue est: %s", mychaine); } free(mychaine);
Si tu veux conserver ta signature, ce qui n'est à mon avis pas une bonne idée, il faut que tu distingues entre une ligne vide et un signal d'erreur/de fin de fichier.
ligne vide => str = "" (en fait { \0 }) mais str pointe bien quelque part
fin de fichier => str = NULL (str pointe à l'adresse 0 du coup)

Et on peut écrire

Code:

while (const char* line = std::getline(stdin) ) // on s'arrête si line == NULL
13/01/2016, 11h12
Matt_Houston

Cette signature semble imposée, voir : http://www.developpez.net/forums/d15...et_next_ligne/ .
13/01/2016, 15h04
SBRKH
@Stendhal666 : Bonjour, comme l'a dit Matt Houston, la signature est imposée.

@Sve@r :

Citation:

Me semble que si tu arrives à la fin de ta fonction, faudrait quand-même lui faire renvoyer quelque chose non ???

Si une des conditions est rempli je return un char*, je renvoie donc quelque chose non?

Citation:

Bien que ce test s'écrive plus facilement return (str[0] != '\0') ?str :NULL;, je ne vois pas trop pourquoi tu renvoies NULL si ta chaine est vide. Une chaine vide reste une chaine, ce n'est pas NULL. De plus, tu cherches un '\0' dans une zone lue avec read() alors que read() ne te garantit pas qu'il te fournira une chaine donc pas forcément de '\0'...

J'ai remplacé le NULL, à la place j'ai fais :
Code:

1 2 3 4 5 6 7 8 if (read(fd, buffer, READ_SIZE) == 0) { if (str[i] != '\0') return (str); *str = '\0'; return (str); }
Citation:

Et ça me fait aussi penser que nulle part tu rajoutes de '\0' à ta zone renvoyée ce qui fait que dans ton main, t'as pas le droit de la lire avec "%s" (ce n'est pas une chaine)...

Je renvoie des char* qui sont des chaines de caractère d'où le %s..
13/01/2016, 15h29
Matt_Houston
Au fait je ne sais pas ce que fait exactement my_realloc mais si c'est un alias de realloc alors ceci :

Code:

str = my_realloc(str, READ_SIZE);

est doublement erroné :
- on alloue toujours READ_SIZE, donc la taille du buffer n'est jamais modifiée ;
- on écrase la valeur de retour, ce qui empêche de détecter une erreur d'allocation.
13/01/2016, 17h22
SBRKH
Citation:
Envoyé par Matt_Houston

Au fait je ne sais pas ce que fait exactement my_realloc mais si c'est un alias de realloc alors ceci :

Code:

str = my_realloc(str, READ_SIZE);

est doublement erroné :

on alloue toujours READ_SIZE, donc la taille du buffer n'est jamais modifiée ;
on écrase la valeur de retour, ce qui empêche de détecter une erreur d'allocation.
Si jamais mon buffer[i] arrive à READ_SIZE et qu'il n'y a toujours pas de '\n', je suis obligé de ré-allouer READ_SIZE pour str non?
13/01/2016, 17h44
Matt_Houston

Oui mais l'argument size de realloc détermine la taille totale de la zone allouée, comme malloc, ce n'est pas un offset. Sinon ce serait un ssize_t (signé). Si ta fonction my_realloc a un comportement similaire (ce que je ne puis affirmer à ce stade) alors cet appel est erroné.

Tu dois conserver la taille courante de ton buffer de destination quelque part et ré-allouer size + READ_SIZE.
13/01/2016, 18h24
Sve@r

Citation:

Envoyé par SBRKH

Si une des conditions est rempli je return un char*, je renvoie donc quelque chose non?

Si tu peux garantir que tu passeras fatalement par ce return, alors c'est ok. C'est pas très clair (généralement, même si on quitte au milieu on a quand-même une fin possible en fin de fonction et là, ça manque ce qui oblige à dérouler l'algo pour vérifier qu'on y passe bien quoi qu'il arrive) mais t'as le droit.

Citation:

Envoyé par SBRKH

Je renvoie des char* qui sont des chaines de caractère d'où le %s..

Non, un char* n'est pas une chaine de caractère !!! Un char* est un type prévu pour stocker un pointeur sur un caractère.
Bien que les chaines de caractères puissent êtres référencées par l'adresse de leur premier élément, adresse qui sera stockée dans un char*, un char* n'est pas une chaine. Ce n'est qu'une adresse qui, peut-être, pointe vers une chaine...

Autre exemple: tous les chats sont des animaux, mais un animal n'est pas forcément un chat...

Une chaine, c'est un tableau de caractères contenant un caractère '\0'. Ainsi char toto[]={'H', 'e', 'l', 'l', 'o'} n'est pas une chaine mais char titi[]={'H', 'e', 'l', 'l', 'o', '\0'} en est une. Et cette seconde écriture peut s'écrire plus simplement char titi[]="Hello" (le compilo la remplace alors par la précédente). Et dans tous les cas t'as le droit d'écrire char *pt1=toto; char*pt2=titi;. Mais t'as pas le droit d'utiliser "toto" ou "pt1" comme une chaine (ou de l'envoyer à une fonction qui s'attend à recevoir une chaine) parce que cette fonction parcourra tout le tableau à la recherche d'un '\0' et continuera au delà s'il le faut => comportement indéterminé (généralement le programme crashe mais ce n'est même pas garanti !!!)

Citation:

Envoyé par SBRKH

Si jamais mon buffer[i] arrive à READ_SIZE et qu'il n'y a toujours pas de '\n', je suis obligé de ré-allouer READ_SIZE pour str non?

Non, tu dois agrandir de READ_SIZE, ce n'est pas la même chose. La fonction realloc() de base ne demande pas combien il faut mettre "en plus" mais combien il faut mettre "au total"