svcadm(1M)을 검색하려면 섹션에서 1M 을 선택하고, 맨 페이지 이름에 svcadm을 입력하고 검색을 누른다.
strdupa(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)