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

개요

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

strncat_s(3c)

Standard C Library Functions                                        string(3C)



NAME
       string,  strcasecmp,  strncasecmp, strcasecmp_l, strncasecmp_l, strcat,
       strncat, strlcat, strchr, strrchr, strchrnul, strcmp, strncmp,  strcpy,
       strncpy,  strlcpy,  stpcpy,  stpncpy, strcspn, strspn, strdup, strndup,
       strdupa, strndupa, strlen, strnlen, strpbrk, strsep,  strstr,  strnstr,
       strcasestr, strtok, strtok_r - string operations
       strcpy_s,  strncpy_s,  strcat_s,  strncat_s, strtok_s, strerror_s, str‐
       errorlen_s, strnlen_s - string operations with additional safety checks

SYNOPSIS
       #include <strings.h>

       int strcasecmp(const char *s1, const char *s2);


       int strncasecmp(const char *s1, const char *s2, size_t n);


       int strcasecmp_l(const char *s1, const char *s2, locale_t locale);


       int strncasecmp_l(const char *s1, const char *s2, size_t n, locale_t locale);


       #include <string.h>

       char *strcat(char *restrict s1, const char *restrict s2);


       char *strncat(char *restrict s1, const char *restrict s2, size_t n);


       size_t strlcat(char *dst, const char *src, size_t dstsize);


       char *strchr(const char *s, int c);


       char *strrchr(const char *s, int c);


       char *strchrnul(const char *s, int c);


       int strcmp(const char *s1, const char *s2);


       int strncmp(const char *s1, const char *s2, size_t n);


       char *strcpy(char *restrict s1, const char *restrict s2);


       char *strncpy(char *restrict s1, const char *restrict s2, size_t n);


       size_t strlcpy(char *dst, const char *src, size_t dstsize);


       char *stpcpy(char *restrict s1, const char *restrict s2);


       char *stpncpy(char *restrict s1, const char *restrict s2, size_t n);


       size_t strcspn(const char *s1, const char *s2);


       size_t strspn(const char *s1, const char *s2);


       char *strdup(const char *s);


       char *strndup(const char *s, size_t size);


       char *strdupa(const char *s);


       char *strndupa(const char *s, size_t size);


       size_t strlen(const char *s);


       size_t strnlen(const char *s, size_t n);


       char *strpbrk(const char *s1, const char *s2);


       char *strsep(char **stringp, const char *delim);


       char *strstr(const char *s1, const char *s2);


       char *strnstr(const char *s1, const char *s2, size_t n);


       char *strcasestr(const char *s1, const char *s2);


       char *strtok(char *restrict s1, const char *restrict s2);


       char *strtok_r(char *s1, const char *s2, char **lasts);


       #define __STDC_WANT_LIB_EXT1__ 1
       #include <stdlib.h>

       errno_t strcpy_s(char *restrict s1, rsize_t s1max,
           const char *restrict s2);


       errno_t strncpy_s(char *restrict s1, rsize_t s1max,
           const char *restrict s2, rsize_t n);


       errno_t strcat_s(char *restrict s1, rsize_t s1max,
           const char *restrict s2);


       errno_t strncat_s(char *restrict s1, rsize_t s1max,
           const char *restrict s2, rsize_t n);


       char *strtok_s(char *restrict s1, rsize_t *restrict s1max,
           const char *restrict s2, char **restrict ptr);


       errno_t strerror_s(char *s, rsize_t maxsize, errno_t errnum);


       size_t strerrorlen_s(errno_t errnum);


       size_t strnlen_s(const char *s, size_t maxsize);

   ISO C++
       #include <string.h>

       const char *strchr(const char *s, int c);


       const char *strpbrk(const char *s1, const char *s2);


       const char *strrchr(const char *s, int c);


       const char *strstr(const char *s1, const char *s2);


       #include <cstring>

       char *std::strchr(char *s, int c);


       char *std::strpbrk(char *s1, const char *s2);


       char *std::strrchr(char *s, int c);


       char *std::strstr(char *s1, const char *s2);

DESCRIPTION
       The arguments s, s1, and s2 point to strings (arrays of characters ter‐
       minated  by a null character). The strcat(), strncat(), strlcat(), str‐
       cpy(), strncpy(), strlcpy(), strsep(), strtok(), and  strtok_r()  func‐
       tions  all  alter  their first argument. Additionally, the strcat() and
       strcpy() functions do not check for overflow of the array.

   strcasecmp(), strncasecmp()
       The strcasecmp() and strncasecmp() functions are case-insensitive  ver‐
       sions  of  strcmp()  and  strncmp() respectively, described below. They
       ignore differences in case when comparing lower and  uppercase  charac‐
       ters,  using the current locale of the process to determine the case of
       the characters.

   strcasecmp_l(), strncasecmp_l()
       The strcasecmp_l() and strncasecmp_l() functions are versions  of  str‐
       casecmp()  and  strncasecmp() respectively. They use locale represented
       by <locale>, instead of current locale of the process.


       The behavior is undefined if  the  <locale>  argument  is  the  special
       locale object LC_GLOBAL_LOCALE or is not a valid locale object handle.

   strcat(), strncat(), strlcat()
       The strcat() function appends a copy of string s2, including the termi‐
       nating null character, to the end of string s1. The strncat()  function
       appends at most n characters. Each returns a pointer to the null-termi‐
       nated result. The initial character of s2 overrides the null  character
       at  the end of s1. If copying takes place between objects that overlap,
       the behavior of strcat(), strncat(), and strlcat() is undefined.


       The strlcat() function appends at most (dstsize-strlen(dst)-1)  charac‐
       ters  of  src to dst (dstsize being the size of the string buffer dst).
       If the string pointed to by dst contains a null-terminated string  that
       fits into dstsize bytes when strlcat() is called, the string pointed to
       by dst will be a null-terminated string  that  fits  in  dstsize  bytes
       (including  the  terminating null character) when it completes, and the
       initial character of src will override the null character at the end of
       dst.  If the string pointed to by dst is longer than dstsize bytes when
       strlcat() is called, the string pointed to by dst will not be  changed.
       The  function  returns  min{dstsize,strlen(dst)}+  strlen(src).  Buffer
       overflow can be checked as follows:

         if (strlcat(dst, src, dstsize) >= dstsize)
                 return −1;


   strchr(), strrchr(), strchrnul()
       The strchr() function returns a pointer to the first  occurrence  of  c
       (converted  to  a  char)  in  string s, or a null pointer if c does not
       occur in the string.


       The strrchr() function returns a pointer to the last occurrence  of  c.
       The null character terminating a string is considered to be part of the
       string.


       The strchrnul() function is similar to strchr() except that if c is not
       found  in  s,  it  returns  a pointer to the null byte at the end of s,
       rather than NULL.

   strcmp(), strncmp()
       The strcmp() function compares two strings byte-by-byte,  according  to
       the  ordering  of your machine's character set. The function returns an
       integer greater than, equal to, or less than 0, if the  string  pointed
       to  by s1 is greater than, equal to, or less than the string pointed to
       by s2 respectively. The sign of a non-zero return value  is  determined
       by  the  sign of the difference between the values of the first pair of
       bytes that differ in the strings being compared. The strncmp() function
       makes the same comparison but looks at a maximum of n bytes. Bytes fol‐
       lowing a null byte are not compared.

   strcpy(), stpcpy(), strncpy(), stpncpy(), strlcpy()
       The strcpy() and stpcpy() functions copy string s2 to s1, including the
       terminating  null character, stopping after the null character has been
       copied. The strcpy() function returns s1. The stpcpy() function returns
       a pointer to the terminating null character copied into the s1 array.


       The strncpy() and stpncpy() functions copy not more than n bytes (bytes
       that follow a null byte are not copied) from the array pointed to by s2
       to  the  array  pointed  to  by  s1. If the array pointed to by s2 is a
       string that is shorter than n bytes, null bytes  are  appended  to  the
       copy  in  the array pointed to by s1, until n bytes in all are written.
       The stpcpy() function returns s1. If s1 contains null bytes,  stpncpy()
       returns  a  pointer  to the first such null byte. Otherwise, it returns
       &s1[n].


       The strlcpy() function copies at  most  dstsize−1  characters  (dstsize
       being  the  size  of the string buffer dst) from src to dst, truncating
       src if necessary. The result is always  null-terminated.  The  function
       returns strlen(src). Buffer overflow can be checked as follows:

         if (strlcpy(dst, src, dstsize) >= dstsize)
                 return −1;



       If  copying  takes  place between objects that overlap, the behavior of
       these functions is undefined.

   strcspn(), strspn()
       The strcspn() function returns the length of  the  initial  segment  of
       string  s1 that consists entirely of characters not from string s2. The
       strspn() function returns the length of the initial segment  of  string
       s1 that consists entirely of characters from string s2.

   strdup(), strndup(), strdupa(), strndupa()
       The  strdup()  function  returns  a  pointer  to a new string that is a
       duplicate of the string pointed to by s. The returned  pointer  can  be
       passed  to  free(). The space for the new string is obtained using mal‐
       loc(3C). If the new  string  cannot  be  created,  a  null  pointer  is
       returned  and  errno  may be set to ENOMEM to indicate that the storage
       space available is insufficient.


       The strndup() function is similar to strdup(), except that it copies at
       most  size  bytes.  If  the  length of s is larger than size, only size
       bytes are copied and a terminating null  byte  is  added.  If  size  is
       larger  than  the length of s, all bytes in s are copied, including the
       terminating null character.


       The strdupa() and strndupa() functions  are  similar  to  strdup()  and
       strndup(), respectively, but use alloca(3C) to allocate the buffer.

   strlen(), strnlen()
       The  strlen()  function returns the number of bytes in s, not including
       the terminating null character.


       The strnlen() function returns the smaller of n or the number of  bytes
       in s, not including the terminating null character. The strnlen() func‐
       tion never examines more than n bytes of the string pointed to by s.

   strpbrk()
       The strpbrk() function returns a pointer to  the  first  occurrence  in
       string  s1  of  any  character  from string s2, or a null pointer if no
       character from s2 exists in s1.

   strsep()
       The strsep() function locates, in the null-terminated string referenced
       by  *stringp, the first occurrence of any character in the string delim
       (or the terminating '\0' character) and replaces it with  a  '\0'.  The
       location  of the next character after the delimiter character (or NULL,
       if the end of the string was reached) is stored in *stringp. The origi‐
       nal value of *stringp is returned.


       An  "empty" field (one caused by two adjacent delimiter characters) can
       be detected  by  comparing  the  location  referenced  by  the  pointer
       returned by strsep() to '\0'.


       If *stringp is initially NULL, strsep() returns NULL.

   strstr(), strnstr(), strcasestr()
       The  strstr()  function  locates  the first occurrence of the string s2
       (excluding the terminating null character) in string s1 and  returns  a
       pointer  to  the located string, or a null pointer if the string is not
       found. If s2 points to a string with zero length (that is,  the  string
       ""), the function returns s1.


       The  strnstr() function locates the first occurrence of the null-termi‐
       nated string s2 in the string s1, where not more than n characters  are
       searched.  Characters  that  appear  after  a  '\0'  character  are not
       searched.


       The strcasestr() function is similar to strstr(), but ignores the  case
       of both strings.

   strtok()
       A sequence of calls to strtok() breaks the string pointed to by s1 into
       a sequence of tokens, each of which is delimited by  a  byte  from  the
       string  pointed  to by s2. The first call in the sequence has s1 as its
       first argument, and is followed by calls with a null pointer  as  their
       first  argument. The separator string pointed to by s2 can be different
       from call to call.


       The first call in the sequence searches the string pointed to by s1 for
       the  first  byte  that is not contained in the current separator string
       pointed to by s2. If no such byte is found, then there are no tokens in
       the  string  pointed  to  by s1 and strtok() returns a null pointer. If
       such a byte is found, it is the start of the first token.


       The strtok() function then searches from there for a byte that is  con‐
       tained  in  the current separator string. If no such byte is found, the
       current token extends to the end of the string pointed to  by  s1,  and
       subsequent  searches  for a token return a null pointer. If such a byte
       is found, it is overwritten by a null byte that terminates the  current
       token.  The  strtok() function saves a pointer to the following byte in
       thread-specific data, from which the next search for a token starts.


       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.


       See Example 1, 2, and 3 in the EXAMPLES section for  examples  of  str‐
       tok() usage and the explanation in NOTES.

   strtok_r()
       The  strtok_r()  function  considers the null-terminated string s1 as a
       sequence of zero or more text tokens separated by spans of one or  more
       characters from the separator string s2. The argument lasts points to a
       user-provided pointer which points to stored information necessary  for
       strtok_r() to continue scanning the same string.


       In the first call to strtok_r(), s1 points to a null-terminated string,
       s2 to a null-terminated string of separator characters, and  the  value
       pointed  to  by  lasts  is  ignored.  The strtok_r() function returns a
       pointer to the first character of the first token, writes a null  char‐
       acter into s1 immediately following the returned token, and updates the
       pointer to which lasts points.


       In subsequent calls, s1 is a null pointer and lasts is  unchanged  from
       the  previous call so that subsequent calls move through the string s1,
       returning successive tokens  until  no  tokens  remain.  The  separator
       string  s2 can be different from call to call. When no token remains in
       s1, a null pointer is returned.


       See Example 3 in the EXAMPLES section  for  an  example  of  strtok_r()
       usage and the explanation in NOTES.

   C11 Bounds Checking Interfaces
       The   strcpy_s(),  strncpy_s(),  strcat_s(),  strncat_s(),  strtok_s(),
       strlen_s(), strerror_s(), and strerrorlen_s() functions are part of the
       C11  bounds checking interfaces specified in the C11 standard, Annex K.
       With the exception of strerrorlen_s(), each provide similar functional‐
       ity  to  their respective non-bounds checking functions, but with addi‐
       tional safety checks in the form of  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  strcpy_s(),
       strncpy_s(),  strcat_s()  and strncat_s() functions return zero, other‐
       wise, they return a non-zero value.


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


       If the length of the requested string is less than maxsize, and no run‐
       time-constraint   violation  is  detected,  the  strerror_s()  function
       returns zero, otherwise, a non-zero value is returned.


       The strerrorlen_s() function returns the length (not including the null
       terminator) in the message string strerror_s() would return.


       The  strnlen_s()  function  returns zero if s is a null pointer. Other‐
       wise, the number of bytes preceding the terminating null  character  is
       returned.  If  there is no terminating null character in the first max‐
       size characters pointed to by s, strnlen_s() returns maxsize.

RETURN VALUES
       The functions will fail if:


       EINVAL       Null pointer is passed or source and destination overlap


       ERANGE       size argument is not valid value


       EOVERFLOW    Destination array is too small



EXAMPLES
       Example 1 Search for word separators



       The following example searches for tokens separated  by  space  charac‐
       ters.


         #include <string.h>
         ...
         char *token;
         char line[] = "LINE TO BE SEPARATED";
         char *search = " ";

         /* Token will point to "LINE". */
         token = strtok(line, search);

         /* Token will point to "TO". */
         token = strtok(NULL, search);



       Example 2 Break a Line.



       The  following example uses strtok() to break a line into two character
       strings separated by any combination of SPACEs, TABs, or NEWLINEs.


         #include <string.h>
         ...
         struct element {
                char *key;
                char *data;
         };
         ...
         char line[LINE_MAX];
         char *key, *data;
         ...
         key = strtok(line, " \n");
         data = strtok(NULL, " \n");



       Example 3 Search for tokens



       The following example uses both strtok() and strtok_r() to  search  for
       tokens  separated  by one or more characters from the string pointed to
       by the second argument, "/".


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

         int main {
             char buf[8]="5/90/45";
             char buf1[14] = "//5//90//45//";
             char *token;
             char *lasts;

             printf("tokenizing \"%s\" with strtok:\n", buf);
             if ((token = strtok(buf, "/")) != NULL) {
                 printf("token = \"%s\"\n", token);
                 while ((token = strtok(NULL, "/")) != NULL) {
                     printf("token = \"%s\"\n", token);
                 }
             }

             printf("\ntokenizing \"%s\" with strtok_r:\n", buf);
             if ((token = strtok_r(buf1, "/", &lasts)) != NULL) {
                 printf("token = \"%s\"\n", token);
                 while ((token = strtok_r(NULL, "/", &lasts)) != NULL) {
                     printf("token = \"%s\"\n", token);
                 }
             }
         }




       When compiled and run, this example produces the following output:


         tokenizing "5/90/45" with strtok():
         token = "5"
         token = "90"
         token = "45"

         tokenizing "//5//90//45//" with strtok_r():
         token = "5"
         token = "90"
         token = "45"



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  _  Interface  StabilityCommitted  _ MT-LevelSee below _
       StandardSee below


   MT-Level
       The strtok() and strdup() functions are MT-Safe.


       The  string(),  strcasecmp(),  strncasecmp(),   strcasecmp_l(),   strn‐
       casecmp_l(),   strcat(),  strncat(),  strlcat(),  strchr(),  strrchr(),
       strchrnul(),  strcmp(),  strncmp(),  strcpy(),  strncpy(),   strlcpy(),
       stpcpy(),   stpncpy(),   strcspn(),   strspn(),  strndup(),  strdupa(),
       strndupa(), strlen(), strnlen(), strpbrk(), strsep(),  strstr(),  strn‐
       str(), strcasestr(), strtok_r() functions are Async-Signal-Safe.


       The  strcpy_s(), strncpy_s(), strcat_s(), strncat_s(), strtok_s(), str‐
       error_s(), strerrorlen_s(), and strnlen_s() functions  cannot  be  used
       safely  in  a  multithreaded  application due to the runtime constraint
       handler. For more information, see  the  runtime_constraint_handler(3C)
       man page.

   Standard
       For all except strlcat(), strlcpy(), and strsep(), see the standards(7)
       man page.

SEE ALSO
       alloca(3C),  malloc(3C),  setlocale(3C),  strxfrm(3C),   attributes(7),
       standards(7), runtime_constraint_handler(3C)

NOTES
       A  single-threaded  application  can  gain access to strtok_r() only by
       defining __EXTENSIONS__ or  by  defining  _POSIX_C_SOURCE  to  a  value
       greater than or equal to 199506L.


       All of these functions assume the default locale "C." For some locales,
       strxfrm(3C) should be applied to the strings before they are passed  to
       the functions.


       The  strtok()  function  is  safe  to use in multithreaded applications
       because it saves its internal state in  a  thread-specific  data  area.
       However, its use is discouraged, even for single-threaded applications.
       The strtok_r() function should be used instead.


       Do not pass the address of a character string literal as  the  argument
       s1  to  either strtok() or strtok_r(). Similarly, do not pass a pointer
       to the address of a character string literal as the argument stringp to
       strsep().  These  functions  can modify the storage pointed to by s1 in
       the case of  strtok()  and  strtok_r()  or  *stringp  in  the  case  of
       strsep().  The  C99  standard  specifies  that attempting to modify the
       storage occupied by a string literal  results  in  undefined  behavior.
       This  allows  compilers (including gcc, clang, and the Oracle Developer
       Studio compilers) to place string literals in  read-only  memory.  Note
       that  in  Example 1 above, this problem is avoided because the variable
       line is declared as a writable array of type char that  is  initialized
       by  a  string  literal  rather  than a pointer to char that points to a
       string literal.



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