Ir para o conteúdo

Última atualização：2026-10-12

Seis métodos de divisão de strings em C++

No desenvolvimento, costumamos dividir uma string longa por um delimitador para obter as strings que queremos; todos dizem que dividir strings em C++ não é tão prático. Hoje vou resumir 5 métodos para dividir strings.

Inclui estilos do C++11 ao C++20, além do estilo C.

Para facilitar a explicação nos artigos seguintes, definimos primeiro um protótipo de função:

  • Parâmetros: duas strings, uma representando a string original e a outra o delimitador

  • Valor de retorno: um array de strings

Nota: versão para preguiçosos, o código completo pode ser obtido na planeta.

1.Divisão com find

O primeiro método é o que todos costumam usar: encontrar primeiro a posição do delimitador, depois dividir a string e adicionar ao array, resultando no código abaixo.

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));
Esse método ainda pode ser otimizado?

A resposta é sim: para deixar o código mais elegante, podemos apagar a cada vez a substring já produzida e manter a lógica do 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.Divisão com Ranges e Views do C++20

No C++20, podemos usar std::ranges::views::split() para criar uma visão do delimitador e, em seguida, usar transform para converter cada subvisão em 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());
                              });
Simples, não? Se alguém não entendeu, tudo bem — vá ler os artigos anteriores sobre C++20.

3.Divisão com regex

Use um objeto std::regex para construir o padrão do delimitador e um std::sregex_token_iterator para percorrer as substrings separadas pelo padrão de expressão regular; -1 indica extrair as strings que não correspondem, ou seja, as strings exceto os delimitadores.

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

4.Divisão com istringstream

O getline só consegue passar um delimitador por vez; portanto, após a divisão, é preciso continuar pulando os delimitadores seguintes.

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.Divisão com strtok estilo C

Use strtok() para dividir a string em tokens e, depois, um laço while para extraí-los um a um.

token = strtok((char*)s.c_str(), delim.c_str());
while (token != NULL) {
  result.push_back(token);
  token = strtok(NULL, delim.c_str());
}
Esses são os métodos mais usados; você conhece outros? Nos vemos na área de comentários. A versão para preguiçosos desta seção, com o código completo, pode ser obtida na planeta.

Tópicos relacionados

Comentários