std:: strtok

Tokenisiert einen nullterminierten Byte-String.

Eine Abfolge von Aufrufen von std::strtok unterteilt die Zeichenkette, auf die str zeigt, in eine Folge von Tokens, die jeweils durch ein Zeichen aus der Zeichenkette begrenzt werden, auf die delim zeigt. Jeder Aufruf in der Abfolge hat ein Suchziel  :

• Wenn str nicht null ist, handelt es sich um den ersten Aufruf in der Sequenz. Das Suchziel ist die nullterminierte Byte-Zeichenkette, auf die str zeigt.
• Wenn str null ist, handelt es sich um einen der nachfolgenden Aufrufe in der Sequenz. Das Suchziel wird durch den vorherigen Aufruf in der Sequenz bestimmt.

Jeder Aufruf in der Sequenz durchsucht das Suchziel nach dem ersten Zeichen, das nicht in der Trennzeichen-Zeichenkette enthalten ist, auf die delim zeigt. Die Trennzeichen-Zeichenkette kann von Aufruf zu Aufruf unterschiedlich sein.

• Wenn kein solches Zeichen gefunden wird, dann gibt es keine Tokens im Suchziel. Das Suchziel für den nächsten Aufruf in der Sequenz bleibt unverändert. ^[1]
• Wenn ein solches Zeichen gefunden wird, ist es der Start des aktuellen Tokens. std::strtok sucht dann von dort aus nach dem ersten Zeichen, das in der Trennzeichen-Zeichenkette enthalten ist.
  • Wenn kein solches Zeichen gefunden wird, erstreckt sich das aktuelle Token bis zum Ende des Suchziels. Das Suchziel für den nächsten Aufruf in der Sequenz ist eine leere Zeichenkette. ^[2]
  • Wenn ein solches Zeichen gefunden wird, wird es durch ein Nullzeichen überschrieben, was das aktuelle Token beendet. Das Suchziel für den nächsten Aufruf in der Sequenz beginnt ab dem folgenden Zeichen.

Wenn str oder delim kein Zeiger auf eine nullterminierte Byte-Zeichenkette ist, ist das Verhalten undefiniert.

1. ↑ Ein Token kann in einem nachfolgenden Aufruf mit einer anderen Trennzeichenfolge weiterhin gebildet werden.
2. ↑ In nachfolgenden Aufrufen können keine weiteren Tokens mehr gebildet werden.

Parameter

Rückgabewert

Gibt einen Zeiger auf das erste Zeichen des nächsten Tokens zurück oder einen Nullzeiger, falls kein Token vorhanden ist.

Hinweise

Diese Funktion ist destruktiv: Sie schreibt die ' \0 ' Zeichen in die Elemente der Zeichenkette str . Insbesondere kann ein String-Literal nicht als erstes Argument von std::strtok verwendet werden.

Jeder Aufruf dieser Funktion modifiziert eine statische Variable: ist nicht Thread-sicher.

Im Gegensatz zu den meisten anderen Tokenizern können die Trennzeichen in std::strtok für jeden nachfolgenden Token unterschiedlich sein und können sogar von den Inhalten der vorherigen Token abhängen.

Mögliche Implementierung

char* strtok(char* str, const char* delim)
{
    static char* buffer;
    if (str != nullptr)
        buffer = str;
    buffer += std::strspn(buffer, delim);
    if (*buffer == '\0')
        return nullptr;
    char* const tokenBegin = buffer;
    buffer += std::strcspn(buffer, delim);
    if (*buffer != '\0')
        *buffer++ = '\0';
    return tokenBegin;
}

Tatsächliche C++-Bibliotheksimplementierungen dieser Funktion delegieren an die C-Bibliothek, wo sie direkt implementiert sein kann (wie in MUSL libc ), oder in Form ihrer wiederkehrenden Version (wie in GNU libc ).

Beispiel

#include <cstring>
#include <iomanip>
#include <iostream>
int main() 
{
    char input[] = "one + two * (three - four)!";
    const char* delimiters = "! +- (*)";
    char* token = std::strtok(input, delimiters);
    while (token)
    {
        std::cout << std::quoted(token) << ' ';
        token = std::strtok(nullptr, delimiters);
    }
    std::cout << "\nContents of the input string now:\n\"";
    for (std::size_t n = 0; n < sizeof input; ++n)
    {
        if (const char c = input[n]; c != '\0')
            std::cout << c;
        else
            std::cout << "\\0";
    }
    std::cout << "\"\n";
}

"one" "two" "three" "four" 
Contents of the input string now:
"one\0+ two\0* (three\0- four\0!\0"

Siehe auch