strncpy, _strncpy_l, wcsncpy, _wcsncpy_l, _mbsncpy, _mbsncpy_l

  • Article

Copie les caractères d'une chaîne vers une autre. Des versions plus sécurisées de ces fonctions sont disponibles ; voir , , wcsncpy_s_strncpy_s_l, _wcsncpy_s_l, , _mbsncpy_s, _mbsncpy_s_l.strncpy_s

Important

_mbsncpy et _mbsncpy_l ne peuvent pas être utilisées dans les applications qui s'exécutent dans Windows Runtime. Pour plus d’informations, consultez Fonctions CRT non prises en charge dans les applications de la plateforme Windows universelle.

Syntaxe

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

Paramètres

strDest
Chaîne de destination.

strSource
Chaîne source.

count
Nombre de caractères à copier.

locale
Paramètres régionaux à utiliser.

Valeur retournée

Retourne strDest. Aucune valeur de retour n'est réservée pour indiquer une erreur.

Notes

La fonction strncpy copie les count premiers caractères de strSource dans strDest et retourne strDest. Si count elle est inférieure ou égale à la longueur, strSourceun caractère Null n’est pas ajouté automatiquement à la chaîne copiée. Si count est supérieur à la longueur de strSource, la chaîne de destination est remplie avec un nombre de caractères null correspondant à la longueur count. Le comportement de strncpy n'est pas défini si les chaînes source et de destination se chevauchent.

Important

strncpy ne vérifie pas si strDest contient suffisamment d'espace ; cela en fait une cause potentielle de dépassements de mémoire tampon. L'argument count limite le nombre de caractères copiés ; il ne s'agit pas d'une limite de la taille de strDest. Consultez l’exemple qui suit. Pour plus d’informations, consultez Éviter les dépassements de mémoire tampon.

S’il strDest s’agit d’un strSourceNULL pointeur ou s’il count est inférieur ou égal à zéro, le gestionnaire de paramètres non valide est appelé, comme décrit dans la validation des paramètres. Si l'exécution est autorisée à se poursuivre, ces fonctions retournent -1 et définissent errno avec la valeur EINVAL.

wcsncpy et _mbsncpy sont des versions à caractères larges et à caractères multioctets de strncpy. Les arguments et la valeur de retour de wcsncpy et _mbsncpy varient en conséquence. Sinon, ces six fonctions se comportent à l'identique.

Les versions de ces fonctions avec le suffixe _l sont identiques, sauf qu'elles utilisent les paramètres régionaux passés au lieu des paramètres régionaux actuels pour leur comportement dépendant des paramètres régionaux. Pour plus d’informations, consultez Locale.

En C++, ces fonctions ont des surcharges de modèle qui appellent les équivalents plus récents et sécurisés de ces fonctions. Pour plus d’informations, consultez Surcharges de modèles sécurisés.

Par défaut, l’état global de cette fonction est limité à l’application. Pour modifier ce comportement, consultez État global dans le CRT.

Mappages de routine de texte générique

TCHAR.H Routine _UNICODE et _MBCS non défini _MBCS Défini _UNICODE Défini
_tcsncpy strncpy _mbsnbcpy wcsncpy
_tcsncpy_l _strncpy_l _mbsnbcpy_l _wcsncpy_l

Remarque

_strncpy_l et _wcsncpy_l n'ont aucune dépendance vis-à-vis des paramètres régionaux ; elles sont uniquement fournies pour _tcsncpy_l et ne sont pas destinées à être appelées directement.

Spécifications

Routine En-tête requis
strncpy <string.h>
wcsncpy <string.h> ou <wchar.h>
_mbsncpy, _mbsncpy_l <mbstring.h>

Pour plus d’informations sur la compatibilité de la plateforme, consultez Compatibilité.

Exemple

L'exemple suivant illustre l'utilisation de la fonction strncpy et montre comment une utilisation incorrecte de celle-ci peut provoquer des bogues de programme et des problèmes de sécurité. Le compilateur génère un avertissement pour chaque appel similaire strncpy à crt_strncpy_x86.c(15) : avertissement C4996 : 'strncpy : Cette fonction ou cette variable peut être dangereuse. Envisagez plutôt d’utiliser strncpy_s . Pour désactiver la dépréciation, utilisez _CRT_SECURE_NO_WARNINGS. Pour plus d’informations, consultez l’aide en ligne.

// 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.
}

Sortie

ZZ
aa bb dd
this is a very long test
dogs like cats
dogs like to chase cars.
Buffer overrun: s = 'ars.' (should be 'test')

La structure des variables automatiques et le niveau de détection d'erreurs et de protection du code peuvent varier en modifiant les paramètres du compilateur. Cet exemple peut donner des résultats différents quand il est généré dans d'autres environnements de compilation ou avec d'autres options de compilateur.

Voir aussi

Manipulation de chaîne
Paramètres régionaux
Interprétation des séquences de caractères multioctets
_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