getline(3)                 Library Functions Manual                 getline(3)

NUME
       getline, getdelim - intrare de <?>iruri delimitate

BIBLIOTECA
       Biblioteca C standard (libc, -lc)

REZUMAT
       #include <stdio.h>

       ssize_t getline(char **restrict lineptr, size_t *restrict n,
                       FILE *restrict stream);
       ssize_t getdelim(char **restrict lineptr, size_t *restrict n,
                       int delim, FILE *restrict stream);

   Cerin<?>e pentru macrocomenzi de testare a caracteristicilor pentru glibc
   (consulta<?>i feature_test_macros(7)):

       getline(), getdelim():
           Incepand cu glibc 2.10
               _POSIX_C_SOURCE >= 200809L
           Inainte de glibc 2.10:
               _GNU_SOURCE

DESCRIERE
       getline() cite<?>te o linie intreaga din stream, stocand adresa din
       memoria tampon care con<?>ine textul in *lineptr.  Memoria tampon este
       terminata cu null <?>i include caracterul de linie noua, daca a fost
       gasit unul.

       Daca *lineptr este stabilit la NULL inainte de apel, atunci getline()
       va aloca o memorie tampon pentru stocarea liniei. Aceasta memorie
       tampon trebuie eliberata de catre programul utilizatorului chiar daca
       getline() a e<?>uat.

       Alternativ, inainte de a apela getline(), *lineptr poate con<?>ine un
       indicator la o memorie tampon alocata de malloc(3) cu o dimensiune de
       *n octe<?>i. In cazul in care memoria tampon nu este suficient de mare
       pentru a con<?>ine linia, getline() o redimensioneaza cu realloc(3),
       actualizand *lineptr <?>i *n, dupa cum este necesar.

       In ambele cazuri, la un apel reu<?>it, *lineptr <?>i *n vor fi
       actualizate pentru a reflecta adresa memoriei tampon <?>i, respectiv,
       dimensiunea alocata.

       getdelim() func<?>ioneaza ca getline(), cu excep<?>ia faptului ca un
       delimitator de linie, altul decat linia noua, poate fi specificat ca
       argument delimiter. La fel ca in cazul getline(), nu se adauga un
       caracter de delimitare daca nu a fost prezent unul in intrare inainte
       de a se ajunge la sfar<?>itul fi<?>ierului.

VALOAREA RETURNATA
       In caz de succes, getline() <?>i getdelim() returneaza numarul de
       caractere citite, inclusiv caracterul de delimitare, dar fara a include
       octetul de terminare nul (,,\0"). Aceasta valoare poate fi utilizata
       pentru a gestiona octe<?>ii nuli incorpora<?>i in linia citita.

       Ambele func<?>ii returneaza -1 in cazul in care nu se reu<?>e<?>te sa
       se citeasca o linie (inclusiv in cazul in care se ajunge la sfar<?>itul
       fi<?>ierului). In cazul unui e<?>ec, errno este configurata pentru a
       indica eroarea.

       Daca *lineptr a fost stabilit la NULL inainte de apel, atunci memoria
       tampon trebuie eliberata de catre programul utilizatorului chiar <?>i
       in caz de e<?>ec.

ERORI-IE<?>IRE
       EINVAL Argumente incorecte (n sau lineptr este NULL, sau stream nu este
              valid).

       ENOMEM A e<?>uat alocarea sau realocarea memoriei tampon de linie.

ATRIBUTE
       Pentru o explica<?>ie a termenilor folosi<?>i in aceasta sec<?>iune, a
       se vedea attributes(7).

       +--------------------------------------+---------------------+---------+
       |Interfa<?>a                           | Atribut             | Valoare |
       +--------------------------------------+---------------------+---------+
       |getline(), getdelim()                 | Siguran<?>a firelor | MT-Safe |
       +--------------------------------------+---------------------+---------+
STANDARDE
       POSIX.1-2008.

ISTORIC
       GNU, POSIX.1-2008.

EXEMPLE
       #define _GNU_SOURCE
       #include <stdio.h>
       #include <stdlib.h>

       int
       main(int argc, char *argv[])
       {
           FILE *stream;
           char *line = NULL;
           size_t len = 0;
           ssize_t nread;

           if (argc != 2) {
               fprintf(stderr, "Utilizare: %s <fi<?>ier>\n", argv[0]);
               exit(EXIT_FAILURE);
           }

           stream = fopen(argv[1], "r");
           if (stream == NULL) {
               perror("fopen");
               exit(EXIT_FAILURE);
           }

           while ((nread = getline(&line, &len, stream)) != -1) {
               printf("Linie preluata de lungime %zd:\n", nread);
               fwrite(line, nread, 1, stdout);
           }

           free(line);
           fclose(stream);
           exit(EXIT_SUCCESS);
       }

CONSULTA<?>I <?>I
       read(2), fgets(3), fopen(3), fread(3), scanf(3)

TRADUCERE
       Traducerea in limba romana a acestui manual a fost facuta de Remus-
       Gabriel Chelu <remusgabriel.chelu@disroot.org>

       Aceasta traducere este documenta<?>ie gratuita; citi<?>i Licen<?>a
       publica generala GNU Versiunea 3
       <https://www.gnu.org/licenses/gpl-3.0.html> sau o versiune ulterioara
       cu privire la condi<?>ii privind drepturile de autor.  NU se asuma
       NICIO RESPONSABILITATE.

       Daca gasi<?>i erori in traducerea acestui manual, va rugam sa
       trimite<?>i un e-mail la <translation-team-ro@lists.sourceforge.net>.

Pagini de manual de Linux 6.06 31 octombrie 2023                    getline(3)