##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# strtok

From cppreference.com
< c‎ | string‎ | byte

Defined in header `<string.h>` |  |
char *strtok( char *str, const char *delim ); |  | (until C99)
char *strtok( char *restrict str, const char *restrict delim ); |  | (since C99)

Finds the next token in a null-terminated byte string pointed to by `str`. The separator characters are identified by null-terminated byte string pointed to by `delim`.

This function is designed to be called multiples times to obtain successive tokens from the same string.

- If str != NULL, the call is treated as the first call to `strtok` for this particular string. The function searches for the first character which is not contained in `delim`.

  - If no such character was found, there are no tokens in `str` at all, and the function returns a null pointer.
  - If such character was found, it is the beginning of the token. The function then searches from that point on for the first character that is contained in `delim`.
    - If no such character was found, `str` has only one token, and future calls to `strtok` will return a null pointer
    - If such character was found, it is replaced by the null character '\0' and the pointer to the following character is stored in a static location for subsequent invocations.
  - The function then returns the pointer to the beginning of the token

- If str == NULL, the call is treated as a subsequent calls to `strtok`: the function continues from where it left in previous invocation. The behavior is the same as if the previously stored pointer is passed as str.

### [edit] Parameters

str | - | pointer to the null-terminated byte string to tokenize
delim | - | pointer to the null-terminated byte string identifying delimiters

### [edit] Return value

Pointer to the beginning of the next token or NULL if there are no more tokens.

### [edit] Note

This function is destructive: it writes the '\0' characters in the elements of the string `str`. In particular, a string literal cannot be used as the first argument of `strtok`.

Each call to this function modifies a static variable: is not thread safe.

### [edit] Example

Run this code

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

    // on GNU gcc, compile with -std=c99 or -std=gnu99
    int main()
    {
        char *str = malloc(20);
        char *tok = NULL;
        int len = 0;

        strcpy(str, "This is a string");
        len = strlen(str);

        printf("string before strtok(): %s\n", str);
        tok = strtok(str, " ");
        while (tok) {
            printf("Token: %s\n", tok);
            tok = strtok(NULL, " ");
        }

        printf("Print mangled string after strtok()\n");
        for (int i = 0; i < len; i++) {
            if (str[i] == '\0') {
                printf("'\\0'");
            } else {
                printf("%c", str[i]);
            }
        }
        printf("\n");
        free(str);

        return 0;
    }

Output:

    string before strtok(): This is a string
    Token: This
    Token: is
    Token: a
    Token: string
    Print mangled string after strtok()
    This'\0'is'\0'a'\0'string

### [edit] See also

C++ documentation for strtok

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=c/string/byte/strtok&oldid=65165"