Teilen Sie eine Zeichenfolge durch mehrere Trennzeichen in Wörter auf

Ich habe Text (sinnvoller Text oder arithmetischer Ausdruck) und möchte ihn in Wörter aufteilen.
Wenn ich ein einzelnes Trennzeichen hätte, würde ich verwenden:

std::stringstream stringStream(inputString);
std::string word;
while(std::getline(stringStream, word, delimiter)) 
{
    wordVector.push_back(word);
}

Wie kann ich die Zeichenfolge mit mehreren Trennzeichen in Token aufteilen?

Angenommen, eines der Trennzeichen ist ein Zeilenumbruch, wird im Folgenden die Zeile gelesen und durch die Trennzeichen weiter geteilt. Für dieses Beispiel habe ich die Trennzeichen Leerzeichen, Apostroph und Semikolon gewählt.

std::stringstream stringStream(inputString);
std::string line;
while(std::getline(stringStream, line)) 
{
    std::size_t prev = 0, pos;
    while ((pos = line.find_first_of(" ';", prev)) != std::string::npos)
    {
        if (pos > prev)
            wordVector.push_back(line.substr(prev, pos-prev));
        prev = pos+1;
    }
    if (prev < line.length())
        wordVector.push_back(line.substr(prev, std::string::npos));
}

Wenn Sie Boost haben, könnten Sie Folgendes verwenden:

#include <boost/algorithm/string.hpp>
std::string inputString("One!Two,Three:Four");
std::string delimiters("|,:");
std::vector<std::string> parts;
boost::split(parts, inputString, boost::is_any_of(delimiters));

Verwenden std::regex

EIN std::regex kann Strings in wenigen Zeilen aufteilen:

std::regex re("[\\|,:]");
std::sregex_token_iterator first{input.begin(), input.end(), re, -1}, last;//the '-1' is what makes the regex split (-1 := what was not matched)
std::vector<std::string> tokens{first, last};

Versuch es selber

Ich weiß nicht, warum niemand auf den manuellen Weg hingewiesen hat, aber hier ist er:

const std::string delims(";,:. \n\t");
inline bool isDelim(char c) {
    for (int i = 0; i < delims.size(); ++i)
        if (delims[i] == c)
            return true;
    return false;
}

und in Funktion:

std::stringstream stringStream(inputString);
std::string word; char c;

while (stringStream) {
    word.clear();

    // Read word
    while (!isDelim((c = stringStream.get()))) 
        word.push_back(c);
    if (c != EOF)
        stringStream.unget();

    wordVector.push_back(word);

    // Read delims
    while (isDelim((c = stringStream.get())));
    if (c != EOF)
        stringStream.unget();
}

Auf diese Weise können Sie etwas Nützliches mit den Delims anstellen, wenn Sie möchten.

Wenn Sie daran interessiert sind, wie Sie es selbst machen und keinen Boost verwenden.

Angenommen, die Trennzeichenfolge kann sehr lang sein – sagen wir M, und jedes Zeichen in Ihrer Zeichenfolge zu prüfen, ob es sich um ein Trennzeichen handelt, würde jeweils O (M) kosten, also in einer Schleife für alle Zeichen in Ihrer ursprünglichen Zeichenfolge, sagen wir mal in der Länge N, ist O(M*N).

Ich würde ein Wörterbuch verwenden (wie eine Karte – “Trennzeichen” zu “Booleans” – aber hier würde ich ein einfaches boolesches Array verwenden, das für jedes Trennzeichen true im Index = ASCII-Wert hat).

Iterieren Sie nun über die Zeichenfolge und prüfen Sie, ob das Zeichen ein Trennzeichen ist, O (1), was uns schließlich O (N) insgesamt ergibt.

Hier ist mein Beispielcode:

const int dictSize = 256;    

vector<string> tokenizeMyString(const string &s, const string &del)
{
    static bool dict[dictSize] = { false};

    vector<string> res;
    for (int i = 0; i < del.size(); ++i) {      
        dict[del[i]] = true;
    }

    string token("");
    for (auto &i : s) {
        if (dict[i]) {
            if (!token.empty()) {
                res.push_back(token);
                token.clear();
            }           
        }
        else {
            token += i;
        }
    }
    if (!token.empty()) {
        res.push_back(token);
    }
    return res;
}


int main()
{
    string delString = "MyDog:Odie, MyCat:Garfield  MyNumber:1001001";
//the delimiters are " " (space) and "," (comma) 
    vector<string> res = tokenizeMyString(delString, " ,");

    for (auto &i : res) {

        cout << "token: " << i << endl;
    }
return 0;
}

Hinweis: tokenizeMyString gibt den Vektor nach Wert zurück und erstellt ihn zuerst auf dem Stack, also nutzen wir hier die Leistung des Compilers >>> RVO – Rückgabewertoptimierung 🙂

Und hier, Ewigkeiten später, eine Lösung mit C++20:

constexpr std::string_view words{"Hello-_-C++-_-20-_-!"};
constexpr std::string_view delimeters{"-_-"};
for (const std::string_view word : std::views::split(words, delimeters)) {
    std::cout << std::quoted(word) << ' ';
}
// outputs: Hello C++ 20!

Erforderliche Header:

#include <ranges>
#include <string_view>

Referenz: https://en.cppreference.com/w/cpp/ranges/split_view

Verwenden der range-v3-Bibliothek von Eric Niebler:

https://godbolt.org/z/ZnxfSa

#include <string>
#include <iostream>
#include "range/v3/all.hpp"

int main()
{
    std::string s = "user1:192.168.0.1|user2:192.168.0.2|user3:192.168.0.3";
    auto words = s  
        | ranges::view::split('|')
        | ranges::view::transform([](auto w){
            return w | ranges::view::split(':');
        });
      ranges::for_each(words, [](auto i){ std::cout << i  << "\n"; });
}