strncpy, _strncpy_l, wcsncpy, _wcsncpy_l, _mbsncpy, _mbsncpy_l

Caracteres de copia de una cadena a otra.Versiones más seguras de estas funciones están disponibles; vea strncpy_s, _strncpy_s_l, wcsncpy_s, _wcsncpy_s_l, _mbsncpy_s, _mbsncpy_s_l.

Nota importanteImportante

_mbsncpy y _mbsncpy_l no se pueden utilizar en las aplicaciones que se ejecutan en Windows en tiempo de ejecución.Para obtener más información, vea Funciones CRT no compatibles con /ZW.

char *strncpy(
   char *strDest,
   const char *strSource,
   size_t count 
);
char *_strncpy_l(
   char *strDest,
   const char *strSource,
   size_t count,
   locale_t locale 
);
wchar_t *wcsncpy(
   wchar_t *strDest,
   const wchar_t *strSource,
   size_t count 
);
wchar_t *_wcsncpy_l(
   wchar_t *strDest,
   const wchar_t *strSource,
   size_t count,
   locale_t locale 
);
unsigned char *_mbsncpy(
   unsigned char *strDest,
   const unsigned char *strSource,
   size_t count 
);
unsigned char *_mbsncpy_l(
   unsigned char *strDest,
   const unsigned char *strSource,
   size_t count,
   _locale_t locale
);
template <size_t size>
char *strncpy(
   char (&strDest)[size],
   const char *strSource,
   size_t count 
); // C++ only
template <size_t size>
char *_strncpy_l(
   char (&strDest)[size],
   const char *strSource,
   size_t count,
   locale_t locale 
); // C++ only
template <size_t size>
wchar_t *wcsncpy(
   wchar_t (&strDest)[size],
   const wchar_t *strSource,
   size_t count 
); // C++ only
template <size_t size>
wchar_t *_wcsncpy_l(
   wchar_t (&strDest)[size],
   const wchar_t *strSource,
   size_t count,
   locale_t locale 
); // C++ only
template <size_t size>
unsigned char *_mbsncpy(
   unsigned char (&strDest)[size],
   const unsigned char *strSource,
   size_t count 
); // C++ only
template <size_t size>
unsigned char *_mbsncpy_l(
   unsigned char (&strDest)[size],
   const unsigned char *strSource,
   size_t count,
   _locale_t locale
); // C++ only

Parámetros

  • strDest
    Cadena de destino.

  • strSource
    Cadena de origen.

  • count
    Número de caracteres que se van a copiar.

  • locale
    Configuración regional a utilizar.

Valor devuelto

Devuelva strDest.No se reserva ningún valor devuelto para indicar un error.

Comentarios

La función de strncpy copia caracteres iniciales de count de strSource a strDest y devuelve strDest.Si es count menor o igual que la longitud de strSource, un carácter null no se agrega automáticamente a la cadena copiada.Si count es mayor que la longitud de strSource, la cadena de destino se completa con los caracteres nulos hasta la longitud count.El comportamiento de strncpy es indefinido si las cadenas de origen y de destino se superponen.

Nota de seguridadNota sobre la seguridad

strncpy no comprueba el espacio suficiente en strDest; esto le crea una causa potencial de saturaciones del búfer.El argumento de count limita el número de caracteres copiado; no es un límite en el tamaño de strDest.Vea el ejemplo siguiente.Para obtener más información, vea Para evitar las saturaciones del búfer.

Si strDest o strSource es un puntero de NULL, o si count es menor o igual que cero, se invoca el controlador no válido de parámetro, tal y como se describe en Validación de parámetros.Si la ejecución puede continuar, estas funciones devuelven -1 y errno establecido en EINVAL

wcsncpy y _mbsncpy son versiones de caracteres anchos y de multibyte- carácter de strncpy.Los argumentos y el valor devuelto de wcsncpy y _mbsncpy varían en consecuencia.Estas seis funciones se comportan exactamente igual de otra manera.

Las versiones de estas funciones con el sufijo de _l son idénticas salvo que utilizan la configuración regional pasado en lugar de la configuración regional actual para su comportamiento configuración regional- dependiente.Para obtener más información, vea Configuración regional.

En C++, estas funciones tienen sobrecargas de plantilla que se invoque según el nuevo, garantiza que sus homólogos de estas funciones.Para obtener más información, vea Sobrecargas de plantilla de seguridad.

Asignaciones de la rutina de Genérico- texto

Rutina de TCHAR.H

_UNICODE y _MBCS no definidos

_MBCS definido

_UNICODE definido

_tcsncpy

strncpy

_mbsnbcpy

wcsncpy

_tcsncpy_l

_strncpy_l

_mbsnbcpy_l

_wcsncpy_l

[!NOTA]

_strncpy_l y _wcsncpy_l no dependen de la configuración regional; se proporcionan solo para _tcsncpy_l y no están diseñados para llamar directamente.

Requisitos

Rutina

Encabezado necesario

strncpy

<string.h>

wcsncpy

<string.h> o <wchar.h>

_mbsncpy, _mbsncpy_l

<mbstring.h>

Para obtener información general de compatibilidad de la plataforma, vea Compatibilidad.

Ejemplo

El siguiente ejemplo muestra el uso de strncpy y su empleado mal para producir errores y problemas de seguridad del programa.El compilador genera una advertencia para cada llamada a strncpy similar al crt_strncpy_x86.c(15) : warning C4996: 'strncpy': This function or variable may be unsafe. Consider using strncpy_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.

// crt_strncpy_x86.c
// Use this command in an x86 developer command prompt to compile: 
// cl /TC /W3 crt_strncpy_x86.c

#include <stdio.h>
#include <string.h>

int main() {
   char t[20];
   char s[20];
   char *p = 0, *q = 0;

   strcpy_s(s, sizeof(s), "AA BB CC");
   // Note: strncpy is deprecated; consider using strncpy_s instead
   strncpy(s, "aa", 2);     // "aa BB CC"         C4996
   strncpy(s + 3, "bb", 2); // "aa bb CC"         C4996
   strncpy(s, "ZZ", 3);     // "ZZ",              C4996
                            // count greater than strSource, null added
   printf("%s\n", s);

   strcpy_s(s, sizeof(s), "AA BB CC");
   p = strstr(s, "BB");
   q = strstr(s, "CC");
   strncpy(s, "aa", p - s - 1);   // "aa BB CC"   C4996
   strncpy(p, "bb", q - p - 1);   // "aa bb CC"   C4996
   strncpy(q, "cc",  q - s);      // "aa bb cc"   C4996
   strncpy(q, "dd", strlen(q));   // "aa bb dd"   C4996
   printf("%s\n", s);

   // some problems with strncpy
   strcpy_s(s, sizeof(s), "test");
   strncpy(t, "this is a very long string", 20 ); // C4996
   // Danger: at this point, t has no terminating null,
   // so the printf continues until it runs into one.
   // In this case, it will print "this is a very long test"
   printf("%s\n", t);

   strcpy_s(t, sizeof(t), "dogs like cats");
   printf("%s\n", t);

   strncpy(t + 10, "to chase cars.", 14); // C4996
   printf("%s\n", t);

   // strncpy has caused a buffer overrun and corrupted string s
   printf("Buffer overrun: s = '%s' (should be 'test')\n", s);
   // Since the stack grows from higher to lower addresses, buffer
   // overruns can corrupt function return addresses on the stack,
   // which can be exploited to run arbitrary code.
}

Output

  
  

El diseño de variables automáticas y de nivel de protección de detección de errores y de código puede variar con los valores cambiados del compilador.Este ejemplo puede tener distintos resultados cuando se integra en otros entornos de compilación o con otras opciones de compilador.

Equivalente en .NET Framework

System::String::Copy

Vea también

Referencia

Manipulación de cadenas (CRT)

Configuración regional

Interpretación de secuencias de Multibyte- Carácter

_mbsnbcpy, _mbsnbcpy_l

strcat, wcscat, _mbscat

strcmp, wcscmp, _mbscmp

strcpy, wcscpy, _mbscpy

strncat, _strncat_l, wcsncat, wcsncat_l, _mbsncat _mbsncat_l

strncmp, wcsncmp, _mbsncmp, _mbsncmp_l

_strnicmp, _wcsnicmp, _mbsnicmp, _strnicmp_l, _wcsnicmp_l, _mbsnicmp_l

strrchr, wcsrchr, _mbsrchr, _mbsrchr_l

_strset, _strset_l, _wcsset, _wcsset_l, _mbsset, _mbsset_l

strspn, wcsspn, _mbsspn, _mbsspn_l

strncpy_s, _strncpy_s_l, wcsncpy_s, _wcsncpy_s_l, _mbsncpy_s, _mbsncpy_s_l

strcpy_s, wcscpy_s, _mbscpy_s