Analyser (diviser) une chaîne en C++ en utilisant le délimiteur de chaîne (C++ standard)

Question

J'analyse une chaîne de caractères en C++ en utilisant la méthode suivante :

using namespace std;

string parsed,input="text to be parsed";
stringstream input_stringstream(input);

if (getline(input_stringstream,parsed,' '))
{
     // do some processing.
}

L'analyse syntaxique avec un délimiteur à caractère unique est correcte. Mais que faire si je veux utiliser une chaîne de caractères comme délimiteur.

Exemple : Je veux me séparer :

scott>=tiger

avec >= comme délimiteur pour que je puisse avoir scott et tiger.

Answer 1

Encore une autre réponse : Ici, j'utilise find_first_not_of fonction de chaîne de caractères qui renvoie à la position du premier caractère qui ne pas correspond à l'un des caractères spécifiés dans le delim.

size_t find_first_not_of(const string& delim, size_t pos = 0) const noexcept;

Exemple :

int main()
{
    size_t start = 0, end = 0;
    std::string str = "scott>=tiger>=cat";
    std::string delim = ">=";
    while ((start = str.find_first_not_of(delim, end)) != std::string::npos)
    {
        end = str.find(delim, start); // finds the 'first' occurance from the 'start'
        std::cout << str.substr(start, end - start)<<std::endl; // extract substring
    }
    return 0;
}

Sortie :

    scott
    tiger
    cat

Answer 2

Je fais cette solution. C'est très simple, toutes les impressions/valeurs sont dans la boucle (pas besoin de vérifier après la boucle).

#include <iostream>
#include <string>

using std::cout;
using std::string;

int main() {
    string s = "it-+is-+working!";
    string d = "-+";

    int firstFindI = 0;
    int secendFindI = s.find(d, 0); // find if have any at all
    while (secendFindI != string::npos)
    {
        secendFindI = s.find(d, firstFindI);
        cout << s.substr(firstFindI, secendFindI - firstFindI) << "\n"; // print sliced part
        firstFindI = secendFindI + d.size(); // add to the search index
    }

}

Le seul inconvénient de cette solution est qu'elle consiste à effectuer une recherche deux fois au départ.

Answer 3

Si vous ne voulez pas modifier la chaîne de caractères (comme dans la réponse de Vincenzo Pii) et vous souhaitez également afficher le dernier jeton, vous pouvez utiliser cette approche :

inline std::vector<std::string> splitString( const std::string &s, const std::string &delimiter ){
    std::vector<std::string> ret;
    size_t start = 0;
    size_t end = 0;
    size_t len = 0;
    std::string token;
    do{ end = s.find(delimiter,start); 
        len = end - start;
        token = s.substr(start, len);
        ret.emplace_back( token );
        start += len + delimiter.length();
        std::cout << token << std::endl;
    }while ( end != std::string::npos );
    return ret;
}

Answer 4

std::vector<std::string> parse(std::string str,std::string delim){
    std::vector<std::string> tokens;
    char *str_c = strdup(str.c_str()); 
    char* token = NULL;

    token = strtok(str_c, delim.c_str()); 
    while (token != NULL) { 
        tokens.push_back(std::string(token));  
        token = strtok(NULL, delim.c_str()); 
    }

    delete[] str_c;

    return tokens;
}

Answer 5

J'utilise l'arithmétique du pointeur. le while interne pour la délimitation de la chaîne si vous vous satify avec le char delimeter juste enlever le while interne simplement. j'espère que c'est correct. si vous remarquez une erreur ou améliorer s'il vous plaît laissez le commentaire.

std::vector<std::string> split(std::string s, std::string delim)
{
    char *p = &s[0];
    char *d = &delim[0];
    std::vector<std::string> res = {""};

    do
    {
        bool is_delim = true;
        char *pp = p;
        char *dd = d;
        while (*dd && is_delim == true)
            if (*pp++ != *dd++)
                is_delim = false;

        if (is_delim)
        {
            p = pp - 1;
            res.push_back("");
        }
        else
            *(res.rbegin()) += *p;
    } while (*p++);

    return res;
}