Analisar (dividir) uma string em C ++ usando delimitador de string (C ++ padrão)

362

Estou analisando uma seqüência de caracteres em C ++ usando o seguinte:

using namespace std;

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

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

A análise com um único delimitador de caracteres é boa. Mas e se eu quiser usar uma string como delimitador.

Exemplo: eu quero dividir:

scott>=tiger

com >=como delimitador para que eu possa obter scott e tigre.

TheCrazyProgrammer
fonte

Respostas:

575

Você pode usar a std::string::find()função para encontrar a posição do seu delimitador de string e, em seguida, usar std::string::substr()para obter um token.

Exemplo:

std::string s = "scott>=tiger";
std::string delimiter = ">=";
std::string token = s.substr(0, s.find(delimiter)); // token is "scott"
  • A find(const string& str, size_t pos = 0)função retorna a posição da primeira ocorrência de strna sequência ou nposse a sequência não for encontrada.

  • A substr(size_t pos = 0, size_t n = npos)função retorna uma substring do objeto, iniciando na posição pose no comprimento npos.


Se você tiver vários delimitadores, depois de extrair um token, poderá removê-lo (delimitador incluído) para prosseguir com as extrações subseqüentes (se desejar preservar a sequência original, basta usar s = s.substr(pos + delimiter.length());):

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

Dessa forma, você pode fazer um loop facilmente para obter cada token.

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

Resultado:

scott
tiger
mushroom
Vincenzo Pii
fonte
66
Para aqueles que não deseja modificar a seqüência de entrada, façasize_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.mart
30
NOTA: mushroomsaídas fora do loop, ou seja,s = mushroom
Don Larynx
11
Essas amostras não extraem o último token da string. Uma amostra minha extraindo um IpV4 de uma string: <code> size_t last = 0; size_t próximo = 0; int índice = 0; while (índice <4) {next = str.find (delimitador, último); auto número = str.substr (último, próximo - último); IPv4 [index ++] = atoi (número.c_str ()); last = next + 1; } </code>
rfog 17/08/15
2
@ hayk.mart Apenas uma observação, seria a seguinte, você precisa adicionar 2 e não 1 devido ao tamanho do delimitador, que tem 2 caracteres :): std :: string s = "scott> = tigre> = cogumelo"; delimitador std :: string = "> ="; size_t last = 0; size_t próximo = 0; while ((próximo = s.find (delimitador, último))! = std :: string :: npos) {std :: cout << s.substr (último, penúltimo) << std :: endl; last = next + 2; } std :: cout << s.substr (last) << std :: endl;
Ervinbosenbacher 30/10/2015
Para obter o "tigre", use std::string token = s.substr(s.find(delimiter) + 1);, se você tem certeza de que ele existe (eu uso +1 no comprimento) ...
#
64

Esse método usa std::string::findsem alterar a sequência original lembrando o início e o fim do token de substring 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);
}
Moswald
fonte
34

Você pode usar a próxima função para dividir a string:

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;
}
Sviatoslav
fonte
5
OMI não funciona como esperado: split("abc","a")retornará um vetor ou uma única string "bc", onde acho que faria mais sentido se tivesse retornado um vetor de elementos ["", "bc"]. Usando str.split()no Python, foi intuitivo para mim que ele retornasse uma string vazia, caso delimfosse encontrada no início ou no final, mas essa é apenas a minha opinião. Enfim, eu só acho que deveria ser mencionado
kyriakosSt
11
Recomendaria vivamente a remoção do if (!token.empty()) problema mencionado pelo @kyriakosSt, bem como de outros problemas relacionados aos delimitadores consecutivos.
31519 Steve Steve
11
Eu removeria meu voto positivo, se pudesse, mas o SO não vai me deixar. O problema levantado pelo @kyriakosSt é um problema e a remoção if (!token.empty())não parece suficiente para corrigi-lo.
bhaller
11
@bhaller este sniplet foi projetado exatamente para pular fragmentos vazios. Se você precisar manter os vazios, receio que você precise escrever outra implementação dividida. Sugira que você publique aqui para o bem da comunidade.
Sviatoslav
32

Para delimitador de string

Divida a string com base em um delimitador de string . Como dividir uma string com "adsf-+qwret-+nvfkbdsj-+orthdfjgh-+dfjrleih"base no delimitador "-+", a saída 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;
}


Resultado

adsf
qwret
nvfkbdsj
orthdfjgh
dfjrleih




Para delimitador de caractere único

Seqüência de caracteres dividida com base em um delimitador de caracteres. Como a divisão de string "adsf+qwer+poui+fdgh"com delimitador "+"produzirá{"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;
}


Resultado

adsf
qwer
poui
fdgh
Arafat Hasan
fonte
Você está retornando vector<string>, acho que chamará o construtor de cópias.
275 Mayur
2
Toda referência que eu vi mostra que a chamada para o construtor de cópias é eliminada nesse contexto.
David Given
Com os compiladores "modernos" (C ++ 03?), Acredito que isso esteja correto, o RVO e / ou a semântica de movimento eliminarão o construtor de cópias.
Kevin
Eu tentei o delimitador de caractere único e, se a string terminar em um delimitador (ou seja, uma coluna csv vazia no final da linha), ela não retornará a string vazia. Ele simplesmente retorna uma string a menos. Por exemplo: 1,2,3,4 \ nA, B, C,
kounoupis 26/03/19
Também tentei o delimitador de strings e, se a string terminar em um delimitador, o último delimitador se tornará parte da última string extraída.
kounoupis
20

Esse código divide as linhas do texto e adiciona todos em um vetor.

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

Chamado por:

vector<string> listFilesMax = split(buffer, "\n");
William Cuervo
fonte
está funcionando muito bem! Eu adicionei list.push_back (s); porque estava faltando.
Stoica Mircea
11
perde a última parte da corda. Após o término do loop while, precisamos adicionar o restante de s como um novo token.
whihathac
Fiz uma edição no exemplo de código para corrigir o push_back ausente.
Fret
11
Será mais agradável #vector<string> split(char *phrase, const string delimiter="\n")
Mayur '17
15

O strtok permite passar vários caracteres como delimitadores. Aposto que se você passou "> =" sua sequência de exemplo seria dividida corretamente (mesmo que> e = sejam contados como delimitadores individuais).

EDIT, se você não quiser usar c_str()a conversão de string para char *, use substr e find_first_of para tokenizar.

string token, mystring("scott>=tiger");
while(token != mystring){
  token = mystring.substr(0,mystring.find_first_of(">="));
  mystring = mystring.substr(mystring.find_first_of(">=") + 1);
  printf("%s ",token.c_str());
}
ryanbwork
fonte
3
Obrigado. Mas eu quero usar apenas C ++ e não nenhuma função C, como strtok()seria necessário que eu usasse a matriz char em vez de string.
TheCrazyProgrammer
2
@TheCrazyProgrammer So? Se uma função C faz o que você precisa, use-a. Este não é um mundo em que as funções C não estejam disponíveis em C ++ (na verdade, elas precisam estar). .c_str()também é barato e fácil.
Qix - MONICA FOI ERRADA EM
11
A verificação de if (token! = Mystring) fornece resultados incorretos se você repetir elementos em sua string. Eu usei seu código para criar uma versão que não possui isso. Como muitas mudanças mudam a resposta fundamentalmente, escrevi minha própria resposta em vez de editá-la. Confira abaixo.
Amber Elferink
5

Aqui está a minha opinião sobre isso. Ele lida com os casos extremos e usa um parâmetro opcional para remover entradas vazias dos resultados.

bool endsWith(const std::string& s, const std::string& suffix)
{
    return s.size() >= suffix.size() &&
           s.substr(s.size() - suffix.size()) == suffix;
}

std::vector<std::string> split(const std::string& s, const std::string& delimiter, const bool& removeEmptyEntries = false)
{
    std::vector<std::string> tokens;

    for (size_t start = 0, end; start < s.length(); start = end + delimiter.length())
    {
         size_t position = s.find(delimiter, start);
         end = position != string::npos ? position : s.length();

         std::string token = s.substr(start, end - start);
         if (!removeEmptyEntries || !token.empty())
         {
             tokens.push_back(token);
         }
    }

    if (!removeEmptyEntries &&
        (s.empty() || endsWith(s, delimiter)))
    {
        tokens.push_back("");
    }

    return tokens;
}

Exemplos

split("a-b-c", "-"); // [3]("a","b","c")

split("a--c", "-"); // [3]("a","","c")

split("-b-", "-"); // [3]("","b","")

split("--c--", "-"); // [5]("","","c","","")

split("--c--", "-", true); // [1]("c")

split("a", "-"); // [1]("a")

split("", "-"); // [1]("")

split("", "-", true); // [0]()
Beder Acosta Borges
fonte
4

Isso deve funcionar perfeitamente para delimitadores de string (ou caractere único). Não esqueça de incluir #include <sstream>.

std::string input = "Alfa=,+Bravo=,+Charlie=,+Delta";
std::string delimiter = "=,+"; 
std::istringstream ss(input);
std::string token;
std::string::iterator it;

while(std::getline(ss, token, *(it = delimiter.begin()))) {
    while(*(++it)) ss.get();
    std::cout << token << " " << '\n';
}

O primeiro loop while extrai um token usando o primeiro caractere do delimitador de string. O segundo loop while ignora o restante do delimitador e para no início do próximo token.

hmofrad
fonte
3

Eu usaria boost::tokenizer. Aqui está a documentação explicando como criar uma função apropriada do tokenizer: http://www.boost.org/doc/libs/1_52_0/libs/tokenizer/tokenizerfunction.htm

Aqui está um que funciona para o seu caso.

struct my_tokenizer_func
{
    template<typename It>
    bool operator()(It& next, It end, std::string & tok)
    {
        if (next == end)
            return false;
        char const * del = ">=";
        auto pos = std::search(next, end, del, del + 2);
        tok.assign(next, pos);
        next = pos;
        if (next != end)
            std::advance(next, 2);
        return true;
    }

    void reset() {}
};

int main()
{
    std::string to_be_parsed = "1) one>=2) two>=3) three>=4) four";
    for (auto i : boost::tokenizer<my_tokenizer_func>(to_be_parsed))
        std::cout << i << '\n';
}
Benjamin Lindley
fonte
3
Obrigado. Mas quero desejar apenas C ++ padrão e não uma biblioteca de terceiros.
TheCrazyProgrammer
@TheCrazyProgrammer: Ok, quando li "Standard C ++", pensei que isso significava que não havia extensões não-padrão, não que você não pudesse usar padrões que correspondam a bibliotecas de terceiros.
Benjamin Lindley
3

A resposta já está lá, mas a resposta selecionada usa a função apagar, que é muito cara, pense em uma string muito grande (em MBs). Portanto, eu uso a função abaixo.

vector<string> split(const string& i_str, const string& i_delim)
{
    vector<string> result;

    size_t found = i_str.find(i_delim);
    size_t startIndex = 0;

    while(found != string::npos)
    {
        string temp(i_str.begin()+startIndex, i_str.begin()+found);
        result.push_back(temp);
        startIndex = found + i_delim.size();
        found = i_str.find(i_delim, startIndex);
    }
    if(startIndex != i_str.size())
        result.push_back(string(i_str.begin()+startIndex, i_str.end()));
    return result;      
}
Shubham Agrawal
fonte
Eu testei isso e funciona. Obrigado! Na minha opinião, essa é a melhor resposta porque, como afirma o respondente original, essa solução reduz a sobrecarga da memória e o resultado é convenientemente armazenado em um vetor. (replica o string.split()método Python .)
Robbie Capps
2

Este é um método completo que divide a string em qualquer delimitador e retorna um vetor das strings cortadas.

É uma adaptação da resposta de ryanbwork. No entanto, sua verificação para: if(token != mystring)fornece resultados incorretos se você repetir elementos em sua string. Esta é a minha solução para esse problema.

vector<string> Split(string mystring, string delimiter)
{
    vector<string> subStringList;
    string token;
    while (true)
    {
        size_t findfirst = mystring.find_first_of(delimiter);
        if (findfirst == string::npos) //find_first_of returns npos if it couldn't find the delimiter anymore
        {
            subStringList.push_back(mystring); //push back the final piece of mystring
            return subStringList;
        }
        token = mystring.substr(0, mystring.find_first_of(delimiter));
        mystring = mystring.substr(mystring.find_first_of(delimiter) + 1);
        subStringList.push_back(token);
    }
    return subStringList;
}
Amber Elferink
fonte
11
Algo assim while (true)é geralmente assustador de ver em um pedaço de código como este. Pessoalmente, eu recomendo reescrever isso para que a comparação com std::string::npos(ou, respectivamente, um cheque contra mystring.size()) torne o while (true)obsoleto.
Joel Bodenmann 04/12/19
1

Se você não deseja modificar a sequência (como na resposta de Vincenzo Pii) e também deseja gerar o último token, convém usar esta abordagem:

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;
}
user2366975
fonte
0
#include<iostream>
#include<algorithm>
using namespace std;

int split_count(string str,char delimit){
return count(str.begin(),str.end(),delimit);
}

void split(string str,char delimit,string res[]){
int a=0,i=0;
while(a<str.size()){
res[i]=str.substr(a,str.find(delimit));
a+=res[i].size()+1;
i++;
}
}

int main(){

string a="abc.xyz.mno.def";
int x=split_count(a,'.')+1;
string res[x];
split(a,'.',res);

for(int i=0;i<x;i++)
cout<<res[i]<<endl;
  return 0;
}

PS: Funciona apenas se os comprimentos das cordas após a divisão forem iguais


fonte
Isso usa a extensão GCC - matriz de comprimento variável.
usar o seguinte comando
0

Função:

std::vector<std::string> WSJCppCore::split(const std::string& sWhat, const std::string& sDelim) {
    std::vector<std::string> vRet;
    int nPos = 0;
    int nLen = sWhat.length();
    int nDelimLen = sDelim.length();
    while (nPos < nLen) {
        std::size_t nFoundPos = sWhat.find(sDelim, nPos);
        if (nFoundPos != std::string::npos) {
            std::string sToken = sWhat.substr(nPos, nFoundPos - nPos);
            vRet.push_back(sToken);
            nPos = nFoundPos + nDelimLen;
            if (nFoundPos + nDelimLen == nLen) { // last delimiter
                vRet.push_back("");
            }
        } else {
            std::string sToken = sWhat.substr(nPos, nLen - nPos);
            vRet.push_back(sToken);
            break;
        }
    }
    return vRet;
}

Testes unitários:

bool UnitTestSplit::run() {
bool bTestSuccess = true;

    struct LTest {
        LTest(
            const std::string &sStr,
            const std::string &sDelim,
            const std::vector<std::string> &vExpectedVector
        ) {
            this->sStr = sStr;
            this->sDelim = sDelim;
            this->vExpectedVector = vExpectedVector;
        };
        std::string sStr;
        std::string sDelim;
        std::vector<std::string> vExpectedVector;
    };
    std::vector<LTest> tests;
    tests.push_back(LTest("1 2 3 4 5", " ", {"1", "2", "3", "4", "5"}));
    tests.push_back(LTest("|1f|2п|3%^|44354|5kdasjfdre|2", "|", {"", "1f", "2п", "3%^", "44354", "5kdasjfdre", "2"}));
    tests.push_back(LTest("|1f|2п|3%^|44354|5kdasjfdre|", "|", {"", "1f", "2п", "3%^", "44354", "5kdasjfdre", ""}));
    tests.push_back(LTest("some1 => some2 => some3", "=>", {"some1 ", " some2 ", " some3"}));
    tests.push_back(LTest("some1 => some2 => some3 =>", "=>", {"some1 ", " some2 ", " some3 ", ""}));

    for (int i = 0; i < tests.size(); i++) {
        LTest test = tests[i];
        std::string sPrefix = "test" + std::to_string(i) + "(\"" + test.sStr + "\")";
        std::vector<std::string> vSplitted = WSJCppCore::split(test.sStr, test.sDelim);
        compareN(bTestSuccess, sPrefix + ": size", vSplitted.size(), test.vExpectedVector.size());
        int nMin = std::min(vSplitted.size(), test.vExpectedVector.size());
        for (int n = 0; n < nMin; n++) {
            compareS(bTestSuccess, sPrefix + ", element: " + std::to_string(n), vSplitted[n], test.vExpectedVector[n]);
        }
    }

    return bTestSuccess;
}
kg-mar
fonte
0
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;
}
XLVII
fonte
-4
std::vector<std::string> split(const std::string& s, char c) {
  std::vector<std::string> v;
  unsigned int ii = 0;
  unsigned int j = s.find(c);
  while (j < s.length()) {
    v.push_back(s.substr(i, j - i));
    i = ++j;
    j = s.find(c, j);
    if (j >= s.length()) {
      v.push_back(s.substr(i, s,length()));
      break;
    }
  }
  return v;
}
Yilei
fonte
11
Por favor, seja mais preciso. Seu código não será compilado. Veja a declaração de "i" e a vírgula em vez de um ponto.
jstuardo