Saltar a contenido

Última actualización：2026-10-12

Seis métodos para dividir cadenas en C++

Normalmente, al desarrollar, dividimos una cadena larga según un separador para obtener las subcadenas que queremos; todo el mundo dice que dividir cadenas en C++ no es tan cómodo, así que hoy resumimos 5 métodos para dividir cadenas.

Incluye la forma de escribir desde C++11 hasta C++20, además del estilo C.

Para facilitar la explicación en artículos posteriores, definimos primero un prototipo de función:

  • Parámetros: dos cadenas, una representa la cadena original y la otra el separador

  • Valor de retorno: un array de cadenas

Nota: versión para perezosos, puedes obtener el código completo en la comunidad 星球.

1. División con find

El primer método es el que todo el mundo suele usar: encontrar primero la posición del separador, dividir la cadena y añadirla al array, de donde sale el código siguiente.

nt start = 0;
int end = s.find(delim);
std::vector<std::string> result;
while (end != std::string::npos) {
  result.push_back(s.substr(start, end - start));
  start = end + delim.size();
  end = s.find(delim, start);
}

result.push_back(s.substr(start, end - start));

¿Se puede optimizar aún más este método?

La respuesta es sí: para que el código parezca más elegante, podemos eliminar cada vez la subcadena ya emitida y mantener la lógica de find igual.

while (end != std::string::npos) {
  result.push_back(s.substr(0, end));
  s.erase(0, end + delim.size());
  end = s.find(delim);
}

2. División con Ranges y Views de C++20

En C++20 podemos usar std::ranges::views::split() para crear una vista del separador y luego usar transform para convertir cada subvista en std::string.

auto split_transform_view = s | std::ranges::views::split(delim) |
                              std::ranges::views::transform([](auto&& str) {
                                return std::string(str.begin(), str.end());
                              });

¿No es sencillísimo? Puede que alguno no lo haya entendido; pues nada, ve a leer el artículo anterior de C++20.

3. División con expresiones regulares

Se construye el patrón del separador con un objeto std::regex y se usa std::sregex_token_iterator para recorrer las subcadenas separadas por el patrón de la expresión regular; -1 indica extraer las cadenas no coincidentes, es decir, las cadenas distintas del separador.

std::regex r(delim);
return {std::sregex_token_iterator(s.begin(), s.end(), r, -1),
        std::sregex_token_iterator()};

4. División con istringstream

getline solo puede pasar un separador cada vez, así que tras dividir hay que seguir saltándose los separadores restantes.

std::istringstream ss(s);
while (std::getline(ss, token, *(it = delim.begin()))) {
    result.push_back(token);
    it++;

    while (it != delim.end() && ss.peek() == *(it)) {
        it++;
        ss.get();
    }
}

5. División con strtok al estilo C

Se usa strtok() para dividir la cadena en tokens y luego un bucle while los extrae uno a uno.

token = strtok((char*)s.c_str(), delim.c_str());
while (token != NULL) {
  result.push_back(token);
  token = strtok(NULL, delim.c_str());
}

Estos son los métodos más habituales; ¿tienes algún otro? Nos vemos en la zona de comentarios; la versión para perezosos de esta sección se puede obtener en la comunidad 星球.

Temas relacionados

Comentarios