Analizar (dividir) una cadena en C++ usando un delimitador de cadena (C++ estándar)

Question 1

Estoy analizando una cadena en C++ usando lo siguiente:

using namespace std;

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

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

El análisis con un delimitador de un solo carácter está bien. Pero, ¿qué pasa si quiero usar una cadena como delimitador?

Ejemplo: Quiero dividir:

scott>=tiger

con >= como delimitador para que pueda obtener scott y tiger.

Question 2

Puedes usar el std::string::find() función para encontrar la posición de su delimitador de cadena, luego use std::string::substr() para obtener una ficha.

Ejemplo:

std::string s = "scott>=tiger";
std::string delimiter = ">=";
std::string token = s.substr(0, s.find(delimiter)); // token is "scott"

los find(const string& str, size_t pos = 0) función devuelve la posición de la primera aparición de str en la cadena, o npos si no se encuentra la cadena.
los substr(size_t pos = 0, size_t n = npos) la función devuelve una subcadena del objeto, comenzando en la posición pos y de longitud npos.

Si tiene varios delimitadores, después de haber extraído un token, puede eliminarlo (delimitador incluido) para continuar con las extracciones posteriores (si desea conservar la cadena original, simplemente use s = s.substr(pos + delimiter.length());):

s.erase(0, s.find(delimiter) + delimiter.length());

De esta manera, puede realizar un bucle fácilmente para obtener cada token.

Ejemplo completo

std::string s = "scott>=tiger>=mushroom";
std::string delimiter = ">=";

size_t pos = 0;
std::string token;
while ((pos = s.find(delimiter)) != std::string::npos) {
    token = s.substr(0, pos);
    std::cout << token << std::endl;
    s.erase(0, pos + delimiter.length());
}
std::cout << s << std::endl;

Producción:

scott
tiger
mushroom

Question 3

Este método utiliza std::string::find sin mutar la cadena original al recordar el principio y el final del token de subcadena anterior.

#include <iostream>
#include <string>

int main()
{
    std::string s = "scott>=tiger";
    std::string delim = ">=";

    auto start = 0U;
    auto end = s.find(delim);
    while (end != std::string::npos)
    {
        std::cout << s.substr(start, end - start) << std::endl;
        start = end + delim.length();
        end = s.find(delim, start);
    }

    std::cout << s.substr(start, end);
}

Question 4

Para delimitador de cadena

Cadena dividida basada en un delimitador de cadena. Como dividir la cadena "adsf-+qwret-+nvfkbdsj-+orthdfjgh-+dfjrleih" basado en el delimitador de cadena "-+"la salida será {"adsf", "qwret", "nvfkbdsj", "orthdfjgh", "dfjrleih"}

#include <iostream>
#include <sstream>
#include <vector>

using namespace std;

// for string delimiter
vector<string> split (string s, string delimiter) {
    size_t pos_start = 0, pos_end, delim_len = delimiter.length();
    string token;
    vector<string> res;

    while ((pos_end = s.find (delimiter, pos_start)) != string::npos) {
        token = s.substr (pos_start, pos_end - pos_start);
        pos_start = pos_end + delim_len;
        res.push_back (token);
    }

    res.push_back (s.substr (pos_start));
    return res;
}

int main() {
    string str = "adsf-+qwret-+nvfkbdsj-+orthdfjgh-+dfjrleih";
    string delimiter = "-+";
    vector<string> v = split (str, delimiter);

    for (auto i : v) cout << i << endl;

    return 0;
}

Producción

adsf
qwret
nvfkbdsj
orthdfjgh
dfjrleih

Para delimitador de un solo carácter

Cadena dividida basada en un delimitador de caracteres. Como dividir la cadena "adsf+qwer+poui+fdgh" con delimitador "+" dará salida {"adsf", "qwer", "poui", "fdg"h}

#include <iostream>
#include <sstream>
#include <vector>

using namespace std;

vector<string> split (const string &s, char delim) {
    vector<string> result;
    stringstream ss (s);
    string item;

    while (getline (ss, item, delim)) {
        result.push_back (item);
    }

    return result;
}

int main() {
    string str = "adsf+qwer+poui+fdgh";
    vector<string> v = split (str, '+');

    for (auto i : v) cout << i << endl;

    return 0;
}

Producción

adsf
qwer
poui
fdgh

Question 5

Puede usar la siguiente función para dividir la cadena:

vector<string> split(const string& str, const string& delim)
{
    vector<string> tokens;
    size_t prev = 0, pos = 0;
    do
    {
        pos = str.find(delim, prev);
        if (pos == string::npos) pos = str.length();
        string token = str.substr(prev, pos-prev);
        if (!token.empty()) tokens.push_back(token);
        prev = pos + delim.length();
    }
    while (pos < str.length() && prev < str.length());
    return tokens;
}

Question 6

También puede usar expresiones regulares para esto:

std::vector<std::string> split(const std::string str, const std::string regex_str)
{
    std::regex regexz(regex_str);
    std::vector<std::string> list(std::sregex_token_iterator(str.begin(), str.end(), regexz, -1),
                                  std::sregex_token_iterator());
    return list;
}

que es equivalente a:

std::vector<std::string> split(const std::string str, const std::string regex_str)
{
    std::sregex_token_iterator token_iter(str.begin(), str.end(), regexz, -1);
    std::sregex_token_iterator end;
    std::vector<std::string> list;
    while (token_iter != end)
    {
        list.emplace_back(*token_iter++);
    }
    return list;
}

y usarlo así:

#include <iostream>
#include <string>
#include <regex>

std::vector<std::string> split(const std::string str, const std::string regex_str)
{   // a yet more concise form!
    return { std::sregex_token_iterator(str.begin(), str.end(), std::regex(regex_str), -1), std::sregex_token_iterator() };
}

int main()
{
    std::string input_str = "lets split this";
    std::string regex_str = " "; 
    auto tokens = split(input_str, regex_str);
    for (auto& item: tokens)
    {
        std::cout<<item <<std::endl;
    }
}

¡Juega con él en línea! http://cpp.sh/9sumb

simplemente puede usar subcadenas, caracteres, etc. como de costumbre, o usar expresiones regulares reales para realizar la división.
¡también es conciso y C++ 11!

Question 7

Una forma de hacerlo con C++20:

#include <iostream>
#include <ranges>
#include <string_view>

int main()
{
    std::string hello = "text to be parsed";
    auto split = hello
        | std::ranges::views::split(' ')
        | std::ranges::views::transform([](auto&& str) { return std::string_view(&*str.begin(), std::ranges::distance(str)); });

    for (auto&& word : split)
    {
        std::cout << word << std::endl;
    }
}

Ver:
https://stackoverflow.com/a/48403210/10771848
https://en.cppreference.com/w/cpp/ranges/split_view

Question 8

Este código divide las líneas del texto y agrega a todos en un vector.

vector<string> split(char *phrase, string delimiter){
    vector<string> list;
    string s = string(phrase);
    size_t pos = 0;
    string token;
    while ((pos = s.find(delimiter)) != string::npos) {
        token = s.substr(0, pos);
        list.push_back(token);
        s.erase(0, pos + delimiter.length());
    }
    list.push_back(s);
    return list;
}

Llamado por:

vector<string> listFilesMax = split(buffer, "\n");

Ejemplo completo

Para delimitador de cadena

Para delimitador de un solo carácter

¿Ha sido útil esta solución?