strncpy_s, _strncpy_s_l, wcsncpy_s, _wcsncpy_s_l, _mbsncpy_s, _mbsncpy_s_l

Makale
03/26/2013

Bir dizenin karakter diğerine kopyalayın.Sürümleri bunlar strncpy, _strncpy_l, wcsncpy, _wcsncpy_l, _mbsncpy, _mbsncpy_l açıklandığı gibi güvenlik geliştirmeleri ile crt güvenlik özellikleri.

Önemli
_mbsncpy_sve _mbsncpy_s_l Windows çalışma zamanı yürütme uygulamalarda kullanılamaz.Daha fazla bilgi için bkz: /zw ile desteklenmeyen crt işlevlerinin.

errno_t strncpy_s(
   char *strDest,
   size_t numberOfElements,
   const char *strSource,
   size_t count
);
errno_t _strncpy_s_l(
   char *strDest,
   size_t numberOfElements,
   const char *strSource,
   size_t count,
   _locale_t locale
);
errno_t wcsncpy_s(
   wchar_t *strDest,
   size_t numberOfElements,
   const wchar_t *strSource,
   size_t count 
);
errno_t _wcsncpy_s_l(
   wchar_t *strDest,
   size_t numberOfElements,
   const wchar_t *strSource,
   size_t count,
   _locale_t locale
);
errno_t _mbsncpy_s(
   unsigned char *strDest,
   size_t numberOfElements,
   const unsigned char *strSource,
   size_t count 
);
errno_t _mbsncpy_s_l(
   unsigned char *strDest,
   size_t numberOfElements,
   const unsigned char *strSource,
   size_t count,
   locale_t locale
);
template <size_t size>
errno_t strncpy_s(
   char (&strDest)[size],
   const char *strSource,
   size_t count
); // C++ only
template <size_t size>
errno_t _strncpy_s_l(
   char (&strDest)[size],
   const char *strSource,
   size_t count,
   _locale_t locale
); // C++ only
template <size_t size>
errno_t wcsncpy_s(
   wchar_t (&strDest)[size],
   const wchar_t *strSource,
   size_t count 
); // C++ only
template <size_t size>
errno_t _wcsncpy_s_l(
   wchar_t (&strDest)[size],
   const wchar_t *strSource,
   size_t count,
   _locale_t locale
); // C++ only
template <size_t size>
errno_t _mbsncpy_s(
   unsigned char (&strDest)[size],
   const unsigned char *strSource,
   size_t count 
); // C++ only
template <size_t size>
errno_t _mbsncpy_s_l(
   unsigned char (&strDest)[size],
   const unsigned char *strSource,
   size_t count,
   locale_t locale
); // C++ only

Parametreler

strDest
Hedef dize.
numberOfElements
Hedef dize, karakter cinsinden boyutu.
strSource
Kaynak dizesi.
count
Kopyalanacak karakter sayısı veya _TRUNCATE.
locale
Kullanılacak yerel ayarı.

Dönüş Değeri

Başarılı olursa, sıfır STRUNCATE kesilme oluştuysa, aksi halde bir hata kodu.

Hata koşulları

strDest	numberOfElements	strSource	Dönüş değeri	İçeriğistrDest
NULL	herhangi bir	herhangi bir	EINVAL	modifiye edilmemiş
herhangi bir	herhangi bir	NULL	EINVAL	strDest0 olarak ayarlanırsa [0]
herhangi bir	0	herhangi bir	EINVAL	modifiye edilmemiş
değilNULL	çok küçük	herhangi bir	ERANGE	strDest0 olarak ayarlanırsa [0]

Notlar

Bu işlevlerin ilk kopyalamaya çalışın D karakterini strSource için strDest, burada D en küçük olan count ve uzunluğu, strSource.Bu, D karakter içinde uygun strDest (boyutu olarak verilir numberOfElements) ve bu karakterleri kopyalanır ve sonunda boş eklenir; yine de null bir sonlandırıcı için yer bırakın Aksi halde, strDest[0] olarak null karakteri ve geçersiz bir parametre için işleyici, açıklandığı gibi çağrılır Parametre doğrulama.

Yukarıdaki paragraf için bir özel durum söz konusudur.count Olan _TRUNCATE, sonra kadarını strSource gibi Sığdır içine strDest yer açmak için her zaman eklenir, sonunda boş bırakarak yine de kopyalanır.

Örnek:

char dst[5];

strncpy_s(dst, 5, "a long string", 5);

Biz soran anlamına gelir strncpy_s beş karakterlik beş arabelleğinin bayt uzunluğunda; kopyalamak için Bu alan için null Sonlandırıcı yok bu yüzden bırakabilir strncpy_s sıfırlardan dizesi ve geçersiz parametre işleyiciyi çağırır.

Kesme davranışı gerektiğinde _TRUNCATE veya (size – 1):

strncpy_s(dst, 5, "a long string", _TRUNCATE);

strncpy_s(dst, 5, "a long string", 4);

Aksine dikkat edin strncpy, count uzunluğundan daha büyük strSource, hedef dize uzunluğu en fazla boş karakter ile azsa değil count.

Davranışını strncpy_s kaynak ve hedef dizeleri üst üste gelirse tanımsızdır.

strDest Veya strSource olan NULL, veya numberOfElements 0, geçersiz bir parametre işleyicisi çağrılır.İşlev verir yürütülmesine devam etmek için izin verilip verilmediğini, EINVAL ve errno için EINVAL.

wcsncpy_sve _mbsncpy_s geniş karakter ve çok baytlı karakter sürümleri strncpy_s.Bağımsız değişkenleri ve dönüş değeri wcsncpy_s ve mbsncpy_s buna göre değişir.Altı bu işlevler aynı şekilde aksi davranır.

Çıkış değeri ayarı tarafından etkilenen LC_CTYPE ; bölgesel ayar kategorisi bkz: setlocale daha fazla bilgi için.Bu işlevler sürümlerini _l soneki kullanan geçerli yerel ayarı için bu yerel ayara bağımlı davranışı; sürümleri ile _l sonek dışında bunun yerine geçirilen yerel ayar parametresi kullandıkları aynı.Daha fazla bilgi için bkz. Yerel ayar.

C++'da, bu işlevleri kullanarak şablon aşırı yükleme tarafından Basitleştirilmiş; aşırı arabellek uzunluğu otomatik olarak çıkarabilir (size baðýmsýz deðiþkeni belirtmek gereğini ortadan kaldırır) ve bunların daha eski, güvenli olmayan işlevler daha yeni ve güvenli karşılıklarıyla otomatik olarak değiştirebilirsiniz.Daha fazla bilgi için bkz. Güvenli şablon aşırı yükleme.

Bu işlevleri hata ayıklama sürümleri arabellek 0xFD ile doldurun.Bu davranışı devre dışı bırakmak için _CrtSetDebugFillThreshold.

Genel metin eşlemeleri yordamına girildi

TCHAR.H yordamına girildi	_UNICODE & _mbcs tanımlanmamış	Tanımlanan _mbcs	Tanımlanan _UNICODE
_tcsncpy_s	strncpy_s	_mbsnbcpy_s	wcsncpy_s
_tcsncpy_s_l	_strncpy_s_l	_mbsnbcpy_s_l	_wcsncpy_s_l

[!NOT]

_strncpy_s_l, _wcsncpy_s_l ve _mbsncpy_s_l hiçbir yerel otomatikleştirmekle varsa ve yalnızca için sağlanan _tcsncpy_s_l ve doğrudan adlı bir ilgisi yoktur.

Gereksinimler

Yordamı	Gerekli başlık
strncpy_s, _strncpy_s_l	<string.h>
wcsncpy_s, _wcsncpy_s_l	<string.h> veya <wchar.h>
_mbsncpy_s, _mbsncpy_s_l	<mbstring.h>

Ek uyumluluk bilgileri için bkz: Uyumluluk giriş.

Örnek

// crt_strncpy_s_1.cpp
// compile with: /MTd

// these #defines enable secure template overloads
// (see last part of Examples() below)
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1 
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT 1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <crtdbg.h>  // For _CrtSetReportMode
#include <errno.h>

// This example uses a 10-byte destination buffer.

errno_t strncpy_s_tester( const char * src,
                          int count )
{
   char dest[10];

   printf( "\n" );

   if ( count == _TRUNCATE )
      printf( "Copying '%s' to %d-byte buffer dest with truncation semantics\n",
               src, _countof(dest) );
   else
      printf( "Copying %d chars of '%s' to %d-byte buffer dest\n",
              count, src, _countof(dest) );

   errno_t err = strncpy_s( dest, _countof(dest), src, count );

   printf( "    new contents of dest: '%s'\n", dest );

   return err;
}


void Examples()
{
   strncpy_s_tester( "howdy", 4 );
   strncpy_s_tester( "howdy", 5 );
   strncpy_s_tester( "howdy", 6 );

   printf( "\nDestination buffer too small:\n" );
   strncpy_s_tester( "Hi there!!", 10 );

   printf( "\nTruncation examples:\n" );

   errno_t err = strncpy_s_tester( "How do you do?", _TRUNCATE );
   printf( "    truncation %s occur\n", err == STRUNCATE ? "did"
                                                       : "did not" );

   err = strncpy_s_tester( "Howdy.", _TRUNCATE );
   printf( "    truncation %s occur\n", err == STRUNCATE ? "did"
                                                       : "did not" );

   printf( "\nSecure template overload example:\n" );

   char dest[10];
   strncpy( dest, "very very very long", 15 );
   // With secure template overloads enabled (see #defines at
   // top of file), the preceding line is replaced by
   //    strncpy_s( dest, _countof(dest), "very very very long", 15 );
   // Instead of causing a buffer overrun, strncpy_s invokes
   // the invalid parameter handler.
   // If secure template overloads were disabled, strncpy would
   // copy 15 characters and overrun the dest buffer.
   printf( "    new contents of dest: '%s'\n", dest );
}

void myInvalidParameterHandler(
   const wchar_t* expression,
   const wchar_t* function, 
   const wchar_t* file, 
   unsigned int line, 
   uintptr_t pReserved)
{
   wprintf(L"Invalid parameter handler invoked: %s\n", expression);
}

int main( void )
{
   _invalid_parameter_handler oldHandler, newHandler;

   newHandler = myInvalidParameterHandler;
   oldHandler = _set_invalid_parameter_handler(newHandler);
   // Disable the message box for assertions.
   _CrtSetReportMode(_CRT_ASSERT, 0);

   Examples();
}

// crt_strncpy_s_2.c
// contrasts strncpy and strncpy_s

#include <stdio.h>
#include <stdlib.h>

int main( void )
{
   char a[20] = "test";
   char s[20];

   // simple strncpy usage:

   strcpy_s( s, 20, "dogs like cats" );
   printf( "Original string:\n   '%s'\n", s );

   // Here we can't use strncpy_s since we don't 
   // want null termination
   strncpy( s, "mice", 4 );
   printf( "After strncpy (no null-termination):\n   '%s'\n", s );
   strncpy( s+5, "love", 4 );
   printf( "After strncpy into middle of string:\n   '%s'\n", s );

   // If we use strncpy_s, the string is terminated 
   strncpy_s( s, _countof(s), "mice", 4 );
   printf( "After strncpy_s (with null-termination):\n   '%s'\n", s );

}