NUME

       getc_unlocked, getchar_unlocked, putc_unlocked, putchar_unlocked - funcții stdio care nu blochează

BIBLIOTECA

       Biblioteca C standard (libc, -lc)

SINOPSIS

       #include <stdio.h>

       int getc_unlocked(FILE *stream);
       int getchar_unlocked(void);
       int putc_unlocked(int c, FILE *stream);
       int putchar_unlocked(int c);

       void clearerr_unlocked(FILE *stream);
       int feof_unlocked(FILE *stream);
       int ferror_unlocked(FILE *stream);
       int fileno_unlocked(FILE *stream);
       int fflush_unlocked(FILE *_Nullable stream);

       int fgetc_unlocked(FILE *stream);
       int fputc_unlocked(int c, FILE *stream);

       size_t fread_unlocked(void ptr[restrict .size * .n],
                             size_t size, size_t n,
                             FILE *restrict stream);
       size_t fwrite_unlocked(const void ptr[restrict .size * .n],
                             size_t size, size_t n,
                             FILE *restrict stream);

       char *fgets_unlocked(char s[restrict .n], int n, FILE *restrict stream);
       int fputs_unlocked(const char *restrict s, FILE *restrict stream);

       #include <wchar.h>

       wint_t getwc_unlocked(FILE *stream);
       wint_t getwchar_unlocked(void);
       wint_t fgetwc_unlocked(FILE *stream);

       wint_t fputwc_unlocked(wchar_t wc, FILE *stream);
       wint_t putwc_unlocked(wchar_t wc, FILE *stream);
       wint_t putwchar_unlocked(wchar_t wc);

       wchar_t *fgetws_unlocked(wchar_t ws[restrict .n], int n,
                             FILE *restrict stream);
       int fputws_unlocked(const wchar_t *restrict ws,
                             FILE *restrict stream);

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

       getc_unlocked(), getchar_unlocked(), putc_unlocked(), putchar_unlocked():
           /* glibc >= 2.24: */ _POSIX_C_SOURCE >= 199309L
               || /* glibc <= 2.23: */ _POSIX_C_SOURCE
               || /* glibc <= 2.19: */ _SVID_SOURCE || _BSD_SOURCE

       clearerr_unlocked(),    feof_unlocked(),    ferror_unlocked(),    fileno_unlocked(),   fflush_unlocked(),
       fgetc_unlocked(), fputc_unlocked(), fread_unlocked(), fwrite_unlocked():
           /* glibc >= 2.19: */ _DEFAULT_SOURCE
               || /* glibc <= 2.19: */ _SVID_SOURCE || _BSD_SOURCE

       fgets_unlocked(),    fputs_unlocked(),    getwc_unlocked(),    getwchar_unlocked(),    fgetwc_unlocked(),
       fputwc_unlocked(), putwchar_unlocked(), fgetws_unlocked(), fputws_unlocked():
           _GNU_SOURCE

DESCRIERE

       Fiecare  dintre  aceste  funcții are același comportament ca și omologul său fără sufixul „_unlocked”, cu
       excepția faptului că nu utilizează blocarea (nu stabilesc ele însele blocaje și nu testează prezența unor
       blocaje stabilite de altele) și, prin urmare, sunt nesigure pentru fire. A se vedea flockfile(3).

ATRIBUTE

       Pentru o explicație a termenilor folosiți în această secțiune, a se vedea attributes(7).
       ┌──────────────────────┬───────────────────┬────────────────────────────────────────────────────────────┐
       │ Interfață            │ Atribut           │ Valoare                                                    │
       ├──────────────────────┼───────────────────┼────────────────────────────────────────────────────────────┤
       │ getc_unlocked(),     │ Siguranța firelor │ MT-Safe race:stream                                        │
       │ putc_unlocked(),     │                   │                                                            │
       │ clearerr_unlocked(), │                   │                                                            │
       │ fflush_unlocked(),   │                   │                                                            │
       │ fgetc_unlocked(),    │                   │                                                            │
       │ fputc_unlocked(),    │                   │                                                            │
       │ fread_unlocked(),    │                   │                                                            │
       │ fwrite_unlocked(),   │                   │                                                            │
       │ fgets_unlocked(),    │                   │                                                            │
       │ fputs_unlocked(),    │                   │                                                            │
       │ getwc_unlocked(),    │                   │                                                            │
       │ fgetwc_unlocked(),   │                   │                                                            │
       │ fputwc_unlocked(),   │                   │                                                            │
       │ putwc_unlocked(),    │                   │                                                            │
       │ fgetws_unlocked(),   │                   │                                                            │
       │ fputws_unlocked()    │                   │                                                            │
       ├──────────────────────┼───────────────────┼────────────────────────────────────────────────────────────┤
       │ getchar_unlocked(),  │ Siguranța firelor │ MT-Unsafe race:stdin                                       │
       │ getwchar_unlocked()  │                   │                                                            │
       ├──────────────────────┼───────────────────┼────────────────────────────────────────────────────────────┤
       │ putchar_unlocked(),  │ Siguranța firelor │ MT-Unsafe race:stdout                                      │
       │ putwchar_unlocked()  │                   │                                                            │
       ├──────────────────────┼───────────────────┼────────────────────────────────────────────────────────────┤
       │ feof_unlocked(),     │ Siguranța firelor │ MT-Safe                                                    │
       │ ferror_unlocked(),   │                   │                                                            │
       │ fileno_unlocked()    │                   │                                                            │
       └──────────────────────┴───────────────────┴────────────────────────────────────────────────────────────┘

STANDARDE

       getc_unlocked()
       getchar_unlocked()
       putc_unlocked()
       putchar_unlocked()
              POSIX.1-2008.

       Altele:
              Niciunul.

ISTORIC

       getc_unlocked()
       getchar_unlocked()
       putc_unlocked()
       putchar_unlocked()
              POSIX.1-2001.

CONSULTAȚI ȘI

       flockfile(3), stdio(3)

TRADUCERE

       Traducerea   în   limba   română   a   acestui   manual   a   fost   făcută   de   Remus-Gabriel    Chelu
       <remusgabriel.chelu@disroot.org>

       Această  traducere  este  documentație  gratuită;  citiți  Licența publică generală GNU Versiunea 3 sau o
       versiune  ulterioară  cu  privire  la  condiții  privind  drepturile  de  autor.   NU  se   asumă   NICIO
       RESPONSABILITATE.

       Dacă  găsiți  erori  în  traducerea  acestui manual, vă rugăm să trimiteți un e-mail la translation-team-
       ro@lists.sourceforge.net.

Pagini de manual de Linux 6.9.1                    2 mai 2024                                  unlocked_stdio(3)