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

2 minutos de lectura

Analizar dividir una cadena en C usando un delimitador de
el programador loco

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.

  • stackoverflow.blog/2019/10/11/… desplácese hacia abajo hasta el #5.

    –Wais Kamal

    6 de marzo de 2021 a las 7:40

  • vea esta pregunta implementar la lectura de archivos y dividir cadenas con c ++ 20.

    – Amir Salar

    19 de julio de 2021 a las 21:01

Analizar dividir una cadena en C usando un delimitador de
Vincenzo Pii

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

  • Para aquellos que no quieran modificar la cadena de entrada, hagan size_t last = 0; size_t next = 0; while ((next = s.find(delimiter, last)) != string::npos) { cout << s.substr(last, next-last) << endl; last = next + 1; } cout << s.substr(last) << endl;

    – Hayk Martirós

    31 de enero de 2015 a las 5:07

  • NOTA: mushroom salidas fuera del bucle, es decir s = mushroom

    – Don Laringe

    31 de enero de 2015 a las 22:22

  • Esas muestras no extraen el último token de la cadena. Una muestra mía extrayendo un IpV4 de una cadena: size_t last = 0; tamaño_t siguiente = 0; índice int = 0; while (index<4) { next = str.find(delimiter, last); número automático = str.substr(último, siguiente - último); IPv4[index++] = atoi(numero.c_str()); último = siguiente + 1; }

    – niebla

    17 de agosto de 2015 a las 8:00


  • @hayk.mart Solo una nota, eso sería lo siguiente, necesita agregar 2 no 1 debido al tamaño del delimitador que es de 2 caracteres :): std::string s = "scott>=tiger>=mushroom"; std::string delimitador = ">="; tamaño_t último = 0; tamaño_t siguiente = 0; while ((next = s.find(delimiter, last)) != std::string::npos) { std::cout << s.substr(last, next-last) << std::endl; último = siguiente + 2; } std::cout << s.substr(último) << std::endl;

    – ervinbosenbacher

    30/10/2015 a las 12:52


  • Me pregunto cuántos de los 615 votantes a favor se perdieron la última línea y están ejecutando errores ocultos en su código de producción. A juzgar por los comentarios, apostaría al menos un puñado. En mi opinión, esta respuesta sería mucho más adecuada si no usara cout y en su lugar lo mostró como una función.

    – Qix - MONICA FUE MALTRATADA

    9 de septiembre de 2020 a las 8:47


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);
}

  • ¿Cómo realizo esta operación en vector donde ambas cadenas en el vector tienen la misma forma y tienen los mismos delimitadores? Solo quiero generar ambas cadenas analizadas de la misma manera que esto funciona para una cadena. Mi "string delim" seguirá siendo el mismo, por supuesto

    – Areeb Muzaffar

    16 de marzo de 2021 a las 21:48

  • ¿No debería ser la última línea más bien s.substr(start, end - start) ? Supongo que esto solo funciona como start + end > size() y como tal siempre se necesita el resto de la cadena ...

    – Jonas Wilms

    12/09/2021 a las 11:10

  • Ya que end == std::string::npossignifica que queremos devolver el token final.

    – Moswald

    12/09/2021 a las 15:34

  • La última línea se puede simplificar aún más para s.substr(start) sin necesidad de especificar la longitud porque extraerá toda la subcadena de trainling si omitimos la longitud.

    – peng

    25 de diciembre de 2021 a las 17:05

1647584530 702 Analizar dividir una cadena en C usando un delimitador de
Arafat Hasan

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

  • tu estas regresando vector<string> Creo que llamará al constructor de copias.

    – Mayur

    27 de noviembre de 2018 a las 8:21

  • Cada referencia que he visto muestra que la llamada al constructor de copias se elimina en ese contexto.

    – David dado

    12 de enero de 2019 a las 9:50

  • Con los compiladores "modernos" (¿C++ 03?), Creo que esto es correcto, RVO y/o la semántica de movimiento eliminarán el constructor de copias.

    –Kevin

    13 de marzo de 2019 a las 14:09

  • Probé el delimitador de un solo carácter, y si la cadena termina en un delimitador (es decir, una columna csv vacía al final de la línea), no devuelve la cadena vacía. Simplemente devuelve una cadena menos. Por ejemplo: 1,2,3,4\nA,B,C,

    – kounoupis

    26 de marzo de 2019 a las 1:42


  • También probé el delimitador de cadena, y si la cadena termina en un delimitador, el último delimitador se convierte en parte de la última cadena extraída.

    – kounoupis

    26 de marzo de 2019 a las 1:44

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;
}

Analizar dividir una cadena en C usando un delimitador de
Hossein

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!

  • Esta debería ser la respuesta correcta, siempre que C ++ 11 esté sobre la mesa, y si no lo está ... deberías usar C ++> = 11, ¡es un cambio de juego!

    – DeusXMachina

    8 de enero de 2021 a las 21:47

  • Por favor, ¿puede explicar la declaración de devolución en la función? split()? Estoy tratando de averiguar cómo se empujan las fichas en el std::vector envase. Gracias.

    – BFamz

    3 de febrero de 2021 a las 13:53


  • ¿Lo escribiría como return std::vector<std::string>{ std::sregex_token_iterator(str.begin(), str.end(), std::regex(regex_str), -1), std::sregex_token_iterator() }; ¿Hacer que sea más obvio para usted cómo se crea y devuelve un std::vector temporal? estamos usando la inicialización de la lista aquí. echar un vistazo aquí

    – Hossein

    3 de febrero de 2021 a las 15:29

  • @DeusXMachina: una buena solución, sin duda. Una advertencia: la "forma aún más concisa". en el último segmento de código no se compilará con _LIBCPP_STD_VER > 11, ya que el método está marcado como "eliminar"... pero los segmentos de código anteriores que no requieren implícitamente la referencia de valor r && compilan y funcionan bien en C++ 2a.

    - pob

    25 de marzo de 2021 a las 4:19

  • @Rika sí, eso funciona. Gracias por tu ayuda.

    – BFamz

    12 abr 2021 a las 13:51

1647584531 626 Analizar dividir una cadena en C usando un delimitador de
Rémy Lebeau

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

  • Esta debería ser la respuesta correcta, siempre que C ++ 11 esté sobre la mesa, y si no lo está ... deberías usar C ++> = 11, ¡es un cambio de juego!

    – DeusXMachina

    8 de enero de 2021 a las 21:47

  • Por favor, ¿puede explicar la declaración de devolución en la función? split()? Estoy tratando de averiguar cómo se empujan las fichas en el std::vector envase. Gracias.

    – BFamz

    3 de febrero de 2021 a las 13:53


  • ¿Lo escribiría como return std::vector<std::string>{ std::sregex_token_iterator(str.begin(), str.end(), std::regex(regex_str), -1), std::sregex_token_iterator() }; ¿Hacer que sea más obvio para usted cómo se crea y devuelve un std::vector temporal? estamos usando la inicialización de la lista aquí. echar un vistazo aquí

    – Hossein

    3 de febrero de 2021 a las 15:29

  • @DeusXMachina: una buena solución, sin duda. Una advertencia: la "forma aún más concisa". en el último segmento de código no se compilará con _LIBCPP_STD_VER > 11, ya que el método está marcado como "eliminar"... pero los segmentos de código anteriores que no requieren implícitamente la referencia de valor r && compilan y funcionan bien en C++ 2a.

    - pob

    25 de marzo de 2021 a las 4:19

  • @Rika sí, eso funciona. Gracias por tu ayuda.

    – BFamz

    12 abr 2021 a las 13:51

1647584531 474 Analizar dividir una cadena en C usando un delimitador de
preocuparse

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");

  • ¡está funcionando muy bien! He agregado list.push_back(s); porque faltaba.

    – Stoica Mircea

    25 de mayo de 2018 a las 11:51


  • se pierde la última parte de la cadena. Después de que termine el ciclo while, debemos agregar el resto de s como un nuevo token.

    - whihathac

    1 de junio de 2018 a las 3:00

  • Realicé una edición en el ejemplo de código para corregir el push_back faltante.

    - preocuparse

    14 de noviembre de 2018 a las 1:25

  • sera mas bonito vector<string> split(char *phrase, const string delimiter="\n")

    – Mayur

    17 de mayo de 2019 a las 9:28

  • Sé que es un poco tarde, pero funcionaría mucho mejor si se agregara esta declaración if antes de enviar if (token != "") list.push_back(token); para evitar añadir cadenas vacías.

    –Oliver Workowski

    16 de julio de 2020 a las 21:37


¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad