wcscat_s(3c) 맨 페이지 - 윈디하나의 솔라나라

개요

섹션
맨 페이지 이름
검색(S)

wcscat_s(3c)

Standard C Library Functions                                      wcstring(3C)



NAME
       wcstring,  wcscasecmp,  wcsncasecmp,  wcscat,  wscat,  wcsncat, wsncat,
       wcscmp, wscmp, wcsncmp, wsncmp, wcscpy, wscpy, wcsncpy, wsncpy, wcpcpy,
       wcpncpy,  wcsdup,  wcslen,  wslen,  wcsnlen,  wcschr,  wschr,  wcsrchr,
       wsrchr, windex, wrindex, wcspbrk, wspbrk, wcswcs, wcsspn, wsspn,  wcsc‐
       spn, wscspn, wcstok, wstok - wide-character string operations
       wcscpy_s,   wcsncpy_s,   wmemcpy_s,  wmemmove_s,  wcscat_s,  wcsncat_s,
       wcstok_s, wcsnlen_s, wcrtomb_s - wide-character string operations  with
       additional safety checks

SYNOPSIS
       #include <wchar.h>

       int wcscasecmp(const wchar_t *ws1, const wchar_t *ws2);


       int wcsncasecmp(const wchar_t ws1*, const wchar_t ws2*, size_t n);


       wchar_t *wcscat(wchar_t *ws1, const wchar_t *ws2);


       wchar_t *wcsncat(wchar_t *restrict ws1, const wchar_t *restrict ws2,
            size_t n);


       int wcscmp(const wchar_t *ws1, const wchar_t *ws2);


       int wcsncmp(const wchar_t *ws1, const wchar_t *ws2, size_t n);


       wchar_t *wcscpy(wchar_t *ws1, const wchar_t *ws2);


       wchar_t *wcscpy(wchar_t *restrict ws1, const wchar_t *restrict ws2);


       wchar_t *wcsncpy(wchar_t *restrict ws1, const wchar_t *restrict ws2,
            size_t n);


       wchar_t *wcpncpy(wchar_t restrict *ws1, const wchar_t *restrict ws2,
            size_t n);


       wchar_t *wcsdup(const wchar_t *s);


       size_t wcslen(const wchar_t *ws);


       size_t wcsnlen(const wchar_t *ws, size_t maxlen);


       wchar_t *wcschr(const wchar_t *ws, wchar_t wc);


       wchar_t *wcsrchr(const wchar_t *ws, wchar_t wc);


       wchar_t *wcspbrk(const wchar_t *ws1, const wchar_t *ws2);


       wchar_t *wcswcs(const wchar_t *ws1, const wchar_t *ws2);


       size_t wcsspn(const wchar_t *ws1, const wchar_t *ws2);


       size_t wcscspn(const wchar_t *ws1, const wchar_t *ws2);


       #include <wchar.h>

       const wchar_t *wcschr(const wchar_t *ws, wchar_t wc);


       const wchar_t *wcspbrk(const wchar_t *ws1, const wchar_t *ws2);


       const wchar_t *wcsrchr(const wchar_t *ws, wchar_t wc);


       #define __STDC_WANT_LIB_EXT1__ 1
       #include <wchar.h>

       errno_t wcscpy_s(wchar_t *restrict ws1, rsize_t ws1max,
           const wchar_t *restrict ws2);


       errno_t wcsncpy_s(wchar_t *restrict ws1, rsize_t ws1max,
           const wchar_t *restrict ws2, rsize_t n);


       errno_t wmemcpy_s(wchar_t *restrict ws1, rsize_t ws1max,
           const wchar_t *restrict ws2, rsize_t n);


       errno_t wmemmove_s(wchar_t *ws1, rsize_t ws1max,
           const wchar_t *ws2, rsize_t n);


       errno_t wcscat_s(wchar_t *restrict ws1, rsize_t ws1max,
           const wchar_t *restrict ws2);


       errno_t wcsncat_s(wchar_t *restrict ws1, rsize_t ws1max,
           const wchar_t *restrict ws2, rsize_t n);


       wchar_t *wcstok_s(wchar_t *restrict ws1, rsize_t *restrict ws1max,
           const wchar_t *restrict ws2, wchar_t **restrict ptr);


       size_t wcsnlen_s(const wchar_t *ws, size_t maxsize);


       errno_t wcrtomb_s(size_t *restrict retval, char *restrict ws,
           rsize_t smax, wchar_t wc, mbstate_t *restrict ps);

   ISO C++
       #include <cwchar>

       wchar_t *std::wcschr(wchar_t *ws, wchar_t wc);


       wchar_t *std::wcspbrk(wchar_t *ws1, const wchar_t *ws2);


       wchar_t *std::wcsrchr(wchar_t *ws, wchar_t wc);

   XPG4, SUS, SUSv2, SUSv3
       wchar_t *wcstok(wchar_t *restrict ws1, const wchar_t *restrict ws2);

   Default and other standards
       wchar_t *wcstok(wchar_t *ws1, const wchar_t *ws2, wchar_t **ptr);


       #include <widec.h>

       wchar_t *wscat(wchar_t *ws1, const wchar_t *ws2);


       wchar_t *wsncat(wchar_t *ws1, const wchar_t *ws2, size_t n);


       int wscmp(const wchar_t *ws1, const wchar_t *ws2);


       int wsncmp(const wchar_t *ws1, const wchar_t *ws2, size_t n);


       wchar_t *wscpy(wchar_t *ws1, const wchar_t *ws2);


       wchar_t *wsncpy(wchar_t *ws1, const wchar_t *ws2, size_t n);


       size_t wslen(const wchar_t *ws);


       wchar_t *wschr(const wchar_t *ws, wchat_t wc);


       wchar_t *wsrchr(const wchar_t *ws, wchat_t wc);


       wchar_t *wspbrk(const wchar_t *ws1, const wchar_t *ws2);


       size_t wsspn(const wchar_t *ws1, const wchar_t *ws2);


       size_t wscspn(const wchar_t *ws1, const wchar_t *ws2);


       wchar_t *wstok(wchar_t *ws1, const wchar_t *ws2);


       wchar_t *windex(const wchar_t *ws, wchar_t wc);


       wchar_t *wrindex(const wchar_t *ws, wchar_t wc);

DESCRIPTION
       These functions operate on wide-character strings terminated by wchar_t
       NULL characters. During appending or copying,  these  routines  do  not
       check for an overflow condition of the receiving string. In the follow‐
       ing, ws, ws1, and ws2 point to wide-character strings terminated  by  a
       wchar_t NULL.

   wcscasecmp(), wcsncasecmp()
       The  wcscasecmp() function is the wide-character equivalent of the str‐
       casecmp(3C) function. It compares the wide-character string pointed  to
       by   ws1  to the wide-character string pointed to by ws2, ignoring case
       differences. It returns 0 if the wide-character strings at ws1 is equal
       to  ws2  except  for case differences. It returns a positive integer if
       ws1  is greater than ws2 and a negative integer if ws1 is smaller  than
       ws2, ignoring case.


       The  wcsncasecmp()  function  is  the  wide-character equivalent of the
       strncasecmp(3C) function. It compares at most  n  wide-characters  from
       the  wide-character  string  pointed  to  by  ws1 to the wide-character
       string pointed to by  ws2,  while  ignoring  differences  in  case.  It
       returns 0 if the wide-character strings at ws1 and ws2, truncated to at
       most length n, are equal except for case  distinctions.  It  returns  a
       positive  integer  if  truncated ws1 is greater than ws2 and a negative
       integer if truncated ws1 is smaller than ws2, ignoring case.

   wcscat(), wscat()
       The wcscat() and wscat() functions append a copy of the  wide-character
       string pointed to by ws2 (including the terminating null wide-character
       code) to the end of the wide-character string pointed to  by  ws1.  The
       initial  wide-character  code of ws2 overwrites the null wide-character
       code at the end of ws1. If copying takes  place  between  objects  that
       overlap, the behavior is undefined. Both functions return s1; no return
       value is reserved to indicate an error.

   wcsncat(), wsncat()
       The wcsncat() and wsncat() functions append not more than n  wide-char‐
       acter  codes  (a null wide-character code and wide-character codes that
       follow it are not appended) from the array pointed to by ws2 to the end
       of  the wide-character string pointed to by ws1. The initial wide-char‐
       acter code of ws2 overwrites the null wide-character code at the end of
       ws1.  A  terminating null wide-character code is always appended to the
       result. Both functions return ws1; no return value is reserved to indi‐
       cate an error.

   wcscmp(), wscmp()
       The  wcscmp()  and  wscmp() functions compare the wide-character string
       pointed to by ws1 to the wide-character string pointed to by  ws2.  The
       sign  of  a non-zero return value is determined by the sign of the dif‐
       ference between the values of the first pair  of  wide-character  codes
       that  differ in the objects being compared. Upon completion, both func‐
       tions return an integer greater than, equal to, or less than  zero,  if
       the  wide-character string pointed to by ws1 is greater than, equal to,
       or less than the wide-character string pointed to by ws2.

   wcsncmp(), wsncmp()
       The wcsncmp() and wsncmp() functions compare not more than n wide-char‐
       acter  codes  (wide-character  codes  that follow a null wide character
       code are not compared) from the array pointed to by ws1  to  the  array
       pointed to by ws2. The sign of a non-zero return value is determined by
       the sign of the difference between the values  of  the  first  pair  of
       wide-character  codes  that  differ in the objects being compared. Upon
       successful completion, both functions return an integer  greater  than,
       equal  to,  or  less  than  zero, if the possibly null-terminated array
       pointed to by ws1 is greater than, equal to, or less than the  possibly
       null-terminated array pointed to by ws2.

   wcscpy(), wscpy(), wcpcpy()
       The  wcscpy(),  wscpy(), and wcpcpy() functions copy the wide-character
       string pointed to by ws2 (including the terminating null wide-character
       code)  into the array pointed to by ws1. If copying takes place between
       objects that overlap, the behavior is undefined.


       The wcscpy() and wscpy() functions return ws1.  The  wcpcpy()  function
       returns  a  pointer  to the terminating null wide-character code copied
       into ws1.

   wcsncpy(), wsncpy(), wcpncpy()
       The wcsncpy(), wsncpy(), and wcpncpy() functions copy not more  than  n
       wide-character  codes  (wide-character  codes  that  follow a null wide
       character code are not copied) from the array pointed to by ws2 to  the
       array  pointed  to  by ws1. If copying takes place between objects that
       overlap, the behavior is undefined.


       If the array pointed to by ws2  is  a  wide-character  string  that  is
       shorter  than  n  wide-character  codes,  null wide-character codes are
       appended to the copy in the array pointed to by ws1, until  a  total  n
       wide-character  codes are written. The wcsncpy() and wsncpy() functions
       return ws1. The wcpncpy() function returns a pointer to the  last  wide
       character written.

   wcsdup()
       The   wcsdup()   function  is  the  wide-character  equivalent  of  the
       strdup(3C) function. It returns  a  pointer  to  a  new  wide-character
       string  whose  initial  contents  is  a duplicate of the wide-character
       string pointed to by s. Memory for the  new  wide-character  string  is
       allocated  with  malloc(3C) and can be freed with a call to free(3C). A
       null pointer is returned and errno set to ENOMEM if there  is  insuffi‐
       cient memory available for the duplicate string.

   wcslen(), wslen(), wcsnlen()
       The wcslen() and wslen() functions compute the number of wide-character
       codes in the wide-character string to which ws  points,  not  including
       the  terminating null wide-character code. Both functions return ws; no
       return value is reserved to indicate an error.


       The wcsnlen() is the wide-character equivalent of the strnlen(3C) func‐
       tion. It returns the number of wide-characters in the string pointed to
       by ws , not including the terminating null wide-character code  but  at
       most maxlen, while never looking beyond the first maxlen characters. It
       returns maxlen if there is  no  terminating  null  wide-character  code
       among the first maxlen wide characters pointed to by ws.

   wcschr(), wschr()
       The wcschr() and wschr() functions locate the first occurrence of wc in
       the wide-character string pointed to by ws. The value of wc must  be  a
       character  representable as a type wchar_t and must be a wide-character
       code corresponding to a valid character in the current locale. The ter‐
       minating null wide-character code is considered to be part of the wide-
       character string. Upon completion, both functions return a  pointer  to
       the  wide-character  code, or a null pointer if the wide-character code
       is not found.

   wcsrchr(), wsrchr()
       The wcsrchr() and wsrchr() functions locate the last occurrence  of  wc
       in  the wide-character string pointed to by ws. The value of wc must be
       a character representable as a type wchar_t and must be a  wide-charac‐
       ter  code corresponding to a valid character in the current locale. The
       terminating null wide-character code is considered to be  part  of  the
       wide-character  string.  Upon  successful  completion,  both  functions
       return a pointer to the wide-character code, or a null  pointer  if  wc
       does not occur in the wide-character string.

   windex(), wrindex()
       The  windex()  and  wrindex()  functions behave the same as wschr() and
       wsrchr(), respectively.

   wcspbrk(), wspbrk()
       The wcspbrk() and wspbrk() functions locate the first occurrence in the
       wide character string pointed to by ws1 of any wide-character code from
       the wide-character string pointed to by ws2.  Upon  successful  comple‐
       tion,  the  function returns a pointer to the wide-character code, or a
       null pointer if no wide-character code from ws2 occurs in ws1.

   wcswcs()
       The wcswcs() function locates the first occurrence in the  wide-charac‐
       ter  string  pointed  to by ws1 of the sequence of wide-character codes
       (excluding the terminating null wide-character code) in the  wide-char‐
       acter  string  pointed to by ws2. Upon successful completion, the func‐
       tion returns a pointer to the located wide-character string, or a  null
       pointer  if  the wide-character string is not found. If ws2 points to a
       wide-character string with zero length, the function returns ws1.

   wcsspn(), wsspn()
       The wcsspn() and wsspn() functions compute the length  of  the  maximum
       initial  segment  of  the wide-character string pointed to by ws1 which
       consists entirely  of  wide-character  codes  from  the  wide-character
       string  pointed  to  by  ws2.  Both functions return the length ws1; no
       return value is reserved to indicate an error.

   wcscspn(), wscspn()
       The wcscspn() and wscspn() functions compute the length of the  maximum
       initial  segment  of  the wide-character string pointed to by ws1 which
       consists entirely of wide-character codes not from  the  wide-character
       string  pointed to by ws2. Both functions return the length of the ini‐
       tial substring of ws1; no return  value  is  reserved  to  indicate  an
       error.

   wcstok(), wstok()
       A  sequence  of  calls  to the wcstok() and wstok() functions break the
       wide-character string pointed to by ws1 into a sequence of tokens, each
       of  which is delimited by a wide-character code from the wide-character
       string pointed to by ws2.

   C11 Bounds Checking Interfaces
       The wcscpy_s(),  wcsncpy_s(),  wmemcpy_s(),  wmemmove_s(),  wcscat_s(),
       wcsncat_s(),  wcstok_s(),  wcsnlen_s(),  and  wcrtomb_s() functions are
       part of the C11 bounds checking interfaces specified in the  C11  stan‐
       dard,  Annex  K. Each provide similar functionality to their respective
       non-bounds checking functions, except  for  additional  checks  on  the
       parameters  passed  and  explicit runtime constraints as defined in the
       C11 standard.  See  runtime_constraint_handler(3C)  and  INCITS/ISO/IEC
       9899:2011.


       If  no  runtime  constraint  violation  is  detected,  the  wcscpy_s(),
       wcsncpy_s(), wmemcpy_s(), wmemmove_s(), wcscat_s(), wcsncat(), and wcr‐
       tomb_s()  functions  return  zero,  otherwise,  they  return a non-zero
       value.


       If a runtime constraint violation is detected, or there  is  no  token,
       the  wcstok_s() function returns a null pointer, otherwise a pointer to
       the first wide character of the token is returned.


       The wcsnlen_s() function returns zero if ws is a null  pointer.  Other‐
       wise, it returns the number of wide-characters in the string pointed to
       by ws, not including the terminating null wide-character  code  but  at
       most maxlen, while never looking beyond the first maxlen characters. It
       returns maxlen if there is  no  terminating  null  wide-character  code
       among the first maxlen wide characters pointed to by ws.

   Default and other standards
       The  third  argument  points  to a caller-provided wchar_t pointer into
       which the wcstok() function stores information necessary for it to con‐
       tinue  scanning  the  same  wide-character string. This argument is not
       available with the XPG4 and SUS versions of wcstok(), nor is it  avail‐
       able with the wstok() function. See standards(7).


       The  first  call  in the sequence has ws1 as its first argument, and is
       followed by calls with a null pointer as their first argument. The sep‐
       arator string pointed to by ws2 may be different from call to call.


       The  first  call  in  the  sequence  searches the wide-character string
       pointed to by ws1 for the first wide-character code that  is  not  con‐
       tained  in  the  current separator string pointed to by ws2. If no such
       wide-character code is found, then there are no  tokens  in  the  wide-
       character  string  pointed to by ws1, and wcstok() and wstok() return a
       null pointer. If such a wide-character code is found, it is  the  start
       of the first token.


       The  wcstok()  and  wstok() functions then search from that point for a
       wide-character code that is contained in the current separator  string.
       If  no  such wide-character code is found, the current token extends to
       the end of the wide-character string pointed to by ws1, and  subsequent
       searches for a token will return a null pointer. If such a wide-charac‐
       ter code is found, it is overwritten by a null  wide  character,  which
       terminates the current token. The wcstok() and wstok() functions save a
       pointer to the following  wide-character  code,  from  which  the  next
       search for a token will start.


       Each  subsequent  call,  with  a null pointer as the value of the first
       argument, starts searching  from  the  saved  pointer  and  behaves  as
       described above.


       Upon  successful  completion,  both  functions  return a pointer to the
       first wide-character code of a token. Otherwise, if there is no  token,
       a null pointer is returned.

ERRORS
       The functions wcscpy_s(), wcsncpy_s(), wcscat_s(), wcstok_s(), and wcr‐
       tomb_s() functions will fail if:


       EINVAL       Null pointer is passed or Source and destination overlap.


       ERANGE       size argument is not a valid value.


       EOVERFLOW    Destination array is too small.




       The functions wmemmove_s() and wcsncat_s() will fail if:


       EINVAL    Null pointer is passed.


       ERANGE    size argument is not a valid value.



ATTRIBUTES
       See attributes(7) for descriptions of the following attributes:


       tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i) ATTRIBUTE  TYPEAT‐
       TRIBUTE VALUE _ CSIEnabled _ Interface StabilityCommitted _ MT-LevelSee
       below _ StandardSee below



       For wcscat(),  wcsncat(),  wcscmp(),  wcsncmp(),  wcscpy(),  wcsncpy(),
       wcslen(),  wcschr(),  wcsrchr(),  wcspbrk(),  wcswcs(), wcsspn(), wcsc‐
       spn(), and wcstok(), see standards(7).


       The  wcstring(),  wcscasecmp(),   wcsncasecmp(),   wcscat(),   wscat(),
       wcsncat(),  wsncat(), wcscmp(), wscmp(), wcsncmp(), wsncmp(), wcscpy(),
       wscpy(), wcsncpy(), wsncpy(), wcpcpy(), wcpncpy(), wcsdup(),  wcslen(),
       wslen(),  wcsnlen(),  wcschr(), wschr(), wcsrchr(), wsrchr(), windex(),
       wrindex(), wcspbrk(), wspbrk(), wcswcs(), wcsspn(), wsspn(), wcscspn(),
       wscspn(),  wcstok(),  wstok()  functions  can  be used safely in multi‐
       threaded applications.


       The wcscpy_s(),  wcsncpy_s(),  wmemcpy_s(),  wmemmove_s(),  wcscat_s(),
       wcsncat_s(),  wcstok_s(), wcsnlen_s(), and wcrtomb_s() functions cannot
       be used safely in a multithreaded application due to the  runtime  con‐
       straint  handler. For more information, see the runtime_constraint_han‐
       dler(3C) man page.

SEE ALSO
       malloc(3C), string(3C), wcswidth(3C), wcwidth(3C), attributes(7), stan‐
       dards(7), runtime_constraint_handler(3C)



Oracle Solaris 11.4               10 Jun 2018                     wcstring(3C)
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.
RSS ATOM XHTML 5 CSS3