stpncpy(3)                 Library Functions Manual                 stpncpy(3)

NUME
       stpncpy, strncpy - umple o memorie tampon de marime fixa cu octe<?>i
       nenuli dintr-un <?>ir de caractere, umpland cu octe<?>i nenuli dupa cum
       este necesar

BIBLIOTECA
       Biblioteca C standard (libc, -lc)

REZUMAT
       #include <string.h>

       char *strncpy(char dst[restrict .dsize], const char *restrict src,
                     size_t dsize);
       char *stpncpy(char dst[restrict .dsize], const char *restrict src,
                     size_t dsize);

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

       stpncpy():
           Incepand cu glibc 2.10
               _POSIX_C_SOURCE >= 200809L
           Inainte de glibc 2.10:
               _GNU_SOURCE

DESCRIERE
       Aceste func<?>ii copiaza octe<?>i nenuli din <?>irul indicat de src in
       matricea indicata de dst. In cazul in care sursa are prea pu<?>ini
       octe<?>i nenuli pentru a umple destina<?>ia, func<?>iile umplu
       destina<?>ia cu octe<?>i nenuli la sfar<?>it. In cazul in care memoria
       tampon de destina<?>ie, limitata de dimensiunea sa, nu este suficient
       de mare pentru a con<?>ine copia, secven<?>a de caractere rezultata
       este trunchiata. Pentru a vedea diferen<?>a dintre cele doua func<?>ii,
       consulta<?>i sec<?>iunea VALOAREA RETURNATA.

       O implementare a acestor func<?>ii ar putea fi:

           char *
           strncpy(char *restrict dst, const char *restrict src, size_t dsize)
           {
               stpncpy(dst, src, dsize);
               return dst;
           }

           char *
           stpncpy(char *restrict dst, const char *restrict src, size_t dsize)
           {
               size_t  dlen;

               dlen = strnlen(src, dsize);
               return memset(mempcpy(dst, src, dlen), 0, dsize - dlen);
           }

VALOAREA RETURNATA
       strncpy()
              returneaza dst.

       stpncpy()
              returneaza un indicator la un octet dupa ultimul caracter din
              secven<?>a de caractere de destina<?>ie.

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

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

       stpncpy()
              POSIX.1-2008.

ISTORIC
       strncpy()
              C89, POSIX.1-2001, SVr4, 4.3BSD.

       stpncpy()
              glibc 1.07.  POSIX.1-2008.

AVERTISMENTE
       Numele acestor func<?>ii este confuz. Aceste func<?>ii produc o
       secven<?>a de caractere cu umplutura nula, nu un <?>ir de caractere (a
       se vedea string_copying(7)). De exemplu:

           strncpy(buf, "1", 5);       // { '1',   0,   0,   0,   0 }
           strncpy(buf, "1234", 5);    // { '1', '2', '3', '4',   0 }
           strncpy(buf, "12345", 5);   // { '1', '2', '3', '4', '5' }
           strncpy(buf, "123456", 5);  // { '1', '2', '3', '4', '5' }

       Este imposibil sa se faca distinc<?>ia intre trunchiere prin rezultatul
       apelului <?>i o secven<?>a de caractere care se potrive<?>te cu memoria
       tampon de destina<?>ie; trunchierea ar trebui detectata prin compararea
       lungimii <?>irului de intrare cu dimensiunea memoriei tampon de
       destina<?>ie.

       Daca ave<?>i de gand sa utiliza<?>i aceasta func<?>ie in apeluri
       inlan<?>uite, ar fi util sa dezvolta<?>i o func<?>ie similara care sa
       accepte un indicator la capatul (un octet dupa ultimul element) al
       memoriei tampon de destina<?>ie in loc de dimensiunea acesteia.

EXEMPLE
       #include <err.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <string.h>

       int
       main(void)
       {
           char    *p;
           char    buf1[20];
           char    buf2[20];
           size_t  len;

           if (sizeof(buf2) < strlen("Salutare lume!"))
               errx("strncpy: truncating character sequence");
           strncpy(buf2, "Salutare lume!", sizeof(buf2));
           len = strnlen(buf2, sizeof(buf2));

           printf("[len = %zu]: ", len);
           fwrite(buf2, 1, len, stdout);
           putchar('\n');

           if (sizeof(buf1) < strlen("Salutare lume!"))
               errx("stpncpy: truncating character sequence");
           p = stpncpy(buf1, "Salutare lume!", sizeof(buf1));
           len = p - buf1;

           printf("[len = %zu]: ", len);
           fwrite(buf1, 1, len, stdout);
           putchar('\n');

           exit(EXIT_SUCCESS);
       }

CONSULTA<?>I <?>I
       wcpncpy(3), string_copying(7)

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 12 februarie 2024                    stpncpy(3)