NAME

SYNOPSIS

#include <strings.h>
int strcasecmp(const char *s1, const char *s2);

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

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

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

#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);

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

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

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

char *stpncpy(char *restrict s1, const char *restrict 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);

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

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

char *strdup(const char *s1);

char *strndup(const char *s1, size_t n);

char *strdupa(const char *s1);

char *strndupa(const char *s1, size_t n);

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 *strcasestr_l(const char *s1, const char *s2, locale_t loc);

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

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

#include <string.h>
const char *strchr(const char *s, int c);

const char *strchrnul(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

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

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

EXAMPLES

The following example searches for tokens separated by space characters.

#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="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);
                }
        }
        buf = "//5//90//45//";
        printf("\ntokenizing \"%s\" with strtok_r():\n", buf);
        if ((token = strtok_r(buf, "/", &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

The strlcat(), strlcpy(), and strsep() functions are Committed. All the rest are Standard.

The strtok(), strdup(), and strndup() functions are MT-Safe. The remaining functions are Async-Signal-Safe.

For all except strlcat(), strlcpy(), and strsep(), see standards(7).

SEE ALSO

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.

Except where noted otherwise, 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 and the Sun Studio compilers when the -xstrconst flag is used) 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.