Jak mogę tokenize ciąg w C ++?

głosy
371

Java ma wygodną metodę podziału:

String str = The quick brown fox;
String[] results = str.split( );

Czy istnieje prosty sposób to zrobić w C ++?

Utwórz 10/09/2008 o 13:10
źródło użytkownik
W innych językach...                            


35 odpowiedzi

głosy
179

Doładowania tokenizer klasa może zrobić tego rodzaju rzeczy dość prosty:

#include <iostream>
#include <string>
#include <boost/foreach.hpp>
#include <boost/tokenizer.hpp>

using namespace std;
using namespace boost;

int main(int, char**)
{
    string text = "token, test   string";

    char_separator<char> sep(", ");
    tokenizer< char_separator<char> > tokens(text, sep);
    BOOST_FOREACH (const string& t, tokens) {
        cout << t << "." << endl;
    }
}

Aktualizacja dla c ++ 11:

#include <iostream>
#include <string>
#include <boost/tokenizer.hpp>

using namespace std;
using namespace boost;

int main(int, char**)
{
    string text = "token, test   string";

    char_separator<char> sep(", ");
    tokenizer<char_separator<char>> tokens(text, sep);
    for (const auto& t : tokens) {
        cout << t << "." << endl;
    }
}
Odpowiedział 11/09/2008 o 03:10
źródło użytkownik

głosy
155

Oto prawdziwy proste:

#include <vector>
#include <string>
using namespace std;

vector<string> split(const char *str, char c = ' ')
{
    vector<string> result;

    do
    {
        const char *begin = str;

        while(*str != c && *str)
            str++;

        result.push_back(string(begin, str));
    } while (0 != *str++);

    return result;
}
Odpowiedział 10/09/2008 o 13:30
źródło użytkownik

głosy
131

Twój prosty przypadek można łatwo zbudowany przy użyciu std::string::findmetody. Jednak przyjrzeć Boost.Tokenizer . Wspaniale. Zwiększ zazwyczaj ma kilka bardzo ciekawych narzędzi łańcuchowych.

Odpowiedział 10/09/2008 o 13:18
źródło użytkownik

głosy
102

Użyj strtok. Moim zdaniem, nie ma potrzeby, aby zbudować klasę wokół tokenizing chyba strtok nie daje Ci to, czego potrzebujesz. Może nie, ale w ponad 15 lat pisania różnych parsowania kodu w C i C ++, zawsze stosowany strtok. Oto przykład

char myString[] = "The quick brown fox";
char *p = strtok(myString, " ");
while (p) {
    printf ("Token: %s\n", p);
    p = strtok(NULL, " ");
}

Kilka zastrzeżenia (które nie mogą własnych potrzeb). Łańcuch jest „zniszczone” w procesie, co oznacza, że ​​znaki są umieszczone EOS inline w miejscach delimter. Prawidłowe użytkowanie może wymagać, aby non-const wersję napisu. Można również zmienić listę Ograniczniki połowie przetworzenia.

W moim zdaniem, powyższy kod jest znacznie prostsze i łatwiejsze w użyciu niż pisanie oddzielną klasę dla niego. Dla mnie jest to jedna z tych funkcji zapewnia, że ​​język i robi to dobrze i czysto. To po prostu rozwiązanie „C w oparciu”. Jest to właściwe, to proste, i nie trzeba pisać dużo dodatkowego kodu :-)

Odpowiedział 10/09/2008 o 14:37
źródło użytkownik

głosy
88

Innym sposobem jest szybkie w użyciu getline. Coś jak:

stringstream ss("bla bla");
string s;

while (getline(ss, s, ' ')) {
 cout << s << endl;
}

Jeśli chcesz, możesz zrobić prosty split()sposób zwracania vector<string>, co jest bardzo przydatne.

Odpowiedział 28/11/2008 o 05:17
źródło użytkownik

głosy
80

Można używać strumieni, iteratory oraz algorytmu kopiowania to zrobić dość bezpośrednio.

#include <string>
#include <vector>
#include <iostream>
#include <istream>
#include <ostream>
#include <iterator>
#include <sstream>
#include <algorithm>

int main()
{
  std::string str = "The quick brown fox";

  // construct a stream from the string
  std::stringstream strstr(str);

  // use stream iterators to copy the stream to the vector as whitespace separated strings
  std::istream_iterator<std::string> it(strstr);
  std::istream_iterator<std::string> end;
  std::vector<std::string> results(it, end);

  // send the vector to stdout.
  std::ostream_iterator<std::string> oit(std::cout);
  std::copy(results.begin(), results.end(), oit);
}
Odpowiedział 10/09/2008 o 13:46
źródło użytkownik

głosy
46

No ludzie urazy, ale dla takiego prostego problemu, robisz rzeczy, sposób zbyt skomplikowane. Istnieje wiele powodów do korzystania z bodźcem . Ale to coś prostego, to jak uderzenie muchę z 20 # sankach.

void
split( vector<string> & theStringVector,  /* Altered/returned value */
       const  string  & theString,
       const  string  & theDelimiter)
{
    UASSERT( theDelimiter.size(), >, 0); // My own ASSERT macro.

    size_t  start = 0, end = 0;

    while ( end != string::npos)
    {
        end = theString.find( theDelimiter, start);

        // If at end, use length=maxLength.  Else use length=end-start.
        theStringVector.push_back( theString.substr( start,
                       (end == string::npos) ? string::npos : end - start));

        // If at end, use start=maxSize.  Else use start=end+delimiter.
        start = (   ( end > (string::npos - theDelimiter.size()) )
                  ?  string::npos  :  end + theDelimiter.size());
    }
}

Na przykład (na razie Douga)

#define SHOW(I,X)   cout << "[" << (I) << "]\t " # X " = \"" << (X) << "\"" << endl

int
main()
{
    vector<string> v;

    split( v, "A:PEP:909:Inventory Item", ":" );

    for (unsigned int i = 0;  i < v.size();   i++)
        SHOW( i, v[i] );
}

I tak, możemy mieć split () zwracają nowy wektor zamiast przechodzenia jednego w. To trywialne zawinąć i przeciążenie. Ale w zależności od tego, co robię, często uważają, że lepiej do ponownego użycia wcześniej istniejących obiektów, a nie zawsze tworzenie nowych. (Tak długo jak nie zapomnij opróżnić wektor pomiędzy!)

Numer referencyjny: http://www.cplusplus.com/reference/string/string/ .

(I został pierwotnie piśmie odpowiedź na pytanie: Douga C ++ Ciągi Modyfikacja i wydobycia na podstawie Separatory (zamknięte) Ale ponieważ Martin York zamknięte to pytanie ze wskaźnikiem tutaj ... Zaraz po prostu uogólniać mój kod.).

Odpowiedział 28/11/2008 o 03:55
źródło użytkownik

głosy
34

Rozbudowa ma silną funkcję dzielone: boost :: :: algorytm podziału .

Przykładowy program:

#include <vector>
#include <boost/algorithm/string.hpp>

int main() {
    auto s = "a,b, c ,,e,f,";
    std::vector<std::string> fields;
    boost::split(fields, s, boost::is_any_of(","));
    for (const auto& field : fields)
        std::cout << "\"" << field << "\"\n";
    return 0;
}

Wydajność:

"a"
"b"
" c "
""
"e"
"f"
""
Odpowiedział 12/09/2008 o 18:20
źródło użytkownik

głosy
23

Wiem, że poprosił o C ++ rozwiązanie, ale może warto rozważyć to pomocne:

Qt

#include <QString>

...

QString str = "The quick brown fox"; 
QStringList results = str.split(" "); 

Przewaga nad impuls w tym przykładzie jest to, że jest to bezpośredni jeden do jednego mapowania do kodu słupka.

Zobacz więcej w dokumentacji Qt

Odpowiedział 04/08/2010 o 18:34
źródło użytkownik

głosy
22

Oto próbka tokenizer klasy, która może robić to, co chcesz

//Header file
class Tokenizer 
{
    public:
        static const std::string DELIMITERS;
        Tokenizer(const std::string& str);
        Tokenizer(const std::string& str, const std::string& delimiters);
        bool NextToken();
        bool NextToken(const std::string& delimiters);
        const std::string GetToken() const;
        void Reset();
    protected:
        size_t m_offset;
        const std::string m_string;
        std::string m_token;
        std::string m_delimiters;
};

//CPP file
const std::string Tokenizer::DELIMITERS(" \t\n\r");

Tokenizer::Tokenizer(const std::string& s) :
    m_string(s), 
    m_offset(0), 
    m_delimiters(DELIMITERS) {}

Tokenizer::Tokenizer(const std::string& s, const std::string& delimiters) :
    m_string(s), 
    m_offset(0), 
    m_delimiters(delimiters) {}

bool Tokenizer::NextToken() 
{
    return NextToken(m_delimiters);
}

bool Tokenizer::NextToken(const std::string& delimiters) 
{
    size_t i = m_string.find_first_not_of(delimiters, m_offset);
    if (std::string::npos == i) 
    {
        m_offset = m_string.length();
        return false;
    }

    size_t j = m_string.find_first_of(delimiters, i);
    if (std::string::npos == j) 
    {
        m_token = m_string.substr(i);
        m_offset = m_string.length();
        return true;
    }

    m_token = m_string.substr(i, j - i);
    m_offset = j;
    return true;
}

Przykład:

std::vector <std::string> v;
Tokenizer s("split this string", " ");
while (s.NextToken())
{
    v.push_back(s.GetToken());
}
Odpowiedział 10/09/2008 o 13:18
źródło użytkownik

głosy
21

Roztwór za pomocą regex_token_iteratorS:

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

using namespace std;

int main()
{
    string str("The quick brown fox");

    regex reg("\\s+");

    sregex_token_iterator iter(str.begin(), str.end(), reg, -1);
    sregex_token_iterator end;

    vector<string> vec(iter, end);

    for (auto a : vec)
    {
        cout << a << endl;
    }
}
Odpowiedział 14/12/2014 o 10:46
źródło użytkownik

głosy
16

pystring jest mała biblioteka, która realizuje kilka funkcji łańcuchowych Pythona, w tym metody podziału:

#include <string>
#include <vector>
#include "pystring.h"

std::vector<std::string> chunks;
pystring::split("this string", chunks);

// also can specify a separator
pystring::split("this-string", chunks, "-");
Odpowiedział 29/12/2011 o 16:17
źródło użytkownik

głosy
15

Jest to proste rozwiązanie tylko STL (~ 5 linii!) Używając std::findi std::find_first_not_ofktóry obsługuje powtórzeń ogranicznika (jak spacjami lub okresów, na przykład), a także natarcia i spływu ograniczników:

#include <string>
#include <vector>

void tokenize(std::string str, std::vector<string> &token_v){
    size_t start = str.find_first_not_of(DELIMITER), end=start;

    while (start != std::string::npos){
        // Find next occurence of delimiter
        end = str.find(DELIMITER, start);
        // Push back the token found into vector
        token_v.push_back(str.substr(start, end-start));
        // Skip all occurences of the delimiter to find new start
        start = str.find_first_not_of(DELIMITER, end);
    }
}

Wypróbuj go na żywo !

Odpowiedział 28/02/2015 o 23:18
źródło użytkownik

głosy
9

Zamieściłem to odpowiedź na podobne pytanie.
Nie wyważać otwartych drzwi. Użyłem liczby bibliotek i najszybszy i najbardziej elastyczny mam natknąć to: C ++ String Toolkit Library .

Oto przykład, jak go używać, jakie pisał gdzie indziej na stackoverflow.

#include <iostream>
#include <vector>
#include <string>
#include <strtk.hpp>

const char *whitespace  = " \t\r\n\f";
const char *whitespace_and_punctuation  = " \t\r\n\f;,=";

int main()
{
    {   // normal parsing of a string into a vector of strings
       std::string s("Somewhere down the road");
       std::vector<std::string> result;
       if( strtk::parse( s, whitespace, result ) )
       {
           for(size_t i = 0; i < result.size(); ++i )
            std::cout << result[i] << std::endl;
       }
    }

    {  // parsing a string into a vector of floats with other separators
       // besides spaces

       std::string t("3.0, 3.14; 4.0");
       std::vector<float> values;
       if( strtk::parse( s, whitespace_and_punctuation, values ) )
       {
           for(size_t i = 0; i < values.size(); ++i )
            std::cout << values[i] << std::endl;
       }
    }

    {  // parsing a string into specific variables

       std::string u("angle = 45; radius = 9.9");
       std::string w1, w2;
       float v1, v2;
       if( strtk::parse( s, whitespace_and_punctuation, w1, v1, w2, v2) )
       {
           std::cout << "word " << w1 << ", value " << v1 << std::endl;
           std::cout << "word " << w2 << ", value " << v2 << std::endl;
       }
    }

    return 0;
}
Odpowiedział 07/01/2014 o 21:33
źródło użytkownik

głosy
8

Sprawdź ten przykład. To może pomóc ..

#include <iostream>
#include <sstream>

using namespace std;

int main ()
{
    string tmps;
    istringstream is ("the dellimiter is the space");
    while (is.good ()) {
        is >> tmps;
        cout << tmps << "\n";
    }
    return 0;
}
Odpowiedział 20/12/2010 o 13:25
źródło użytkownik

głosy
5

Można po prostu użyć zwykłego biblioteki ekspresyjnej i rozwiązać, że używanie wyrażeń regularnych.

Użyj wyrażenia (\ w +) i zmienną w \ 1 (lub $ 1 W zależności od implementacji biblioteki wyrażeń regularnych).

Odpowiedział 22/04/2011 o 01:14
źródło użytkownik

głosy
4

Odpowiedź Adama Pierce'a zapewnia ręcznie obrócił tokenizera biorąc w const char*. To trochę bardziej problematyczne zrobić z iteratorów ponieważ zwiększający się stringkrańcu iteracyjnej jest niezdefiniowany . Mimo to, biorąc pod uwagę string str{ "The quick brown fox" }z pewnością możemy to osiągnąć:

auto start = find(cbegin(str), cend(str), ' ');
vector<string> tokens{ string(cbegin(str), start) };

while (start != cend(str)) {
    const auto finish = find(++start, cend(str), ' ');

    tokens.push_back(string(start, finish));
    start = finish;
}

Live Example


Jeśli szukasz do abstrakcyjnego złożoności za pomocą standardowych funkcji, jak sugeruje Na Freund strtok jest prostym rozwiązaniem:

vector<string> tokens;

for (auto i = strtok(data(str), " "); i != nullptr; i = strtok(nullptr, " ")) tokens.push_back(i);

Jeśli nie masz dostępu do C ++ 17 trzeba zastąpić data(str), jak w poniższym przykładzie: http://ideone.com/8kAGoa

Chociaż nie wykazano w przykładzie, strtoknie muszą używać tego samego ogranicznika dla każdego tokenu. Wraz z tym korzyść choć istnieje kilka wad:

  1. strtoknie może być stosowany na wielu stringsw tym samym czasie: albo nullptrmuszą być przekazane do dalszego tokenizing aktualny stringlub nowy char*do tokenize muszą być przekazywane (istnieją pewne niestandardowe implementacje, które obsługują ten jednak, jak: strtok_s)
  2. Z tego samego powodu strtoknie może być stosowany na wielu wątków jednocześnie (może to być jednak wdrożenie zdefiniowane, na przykład: realizacja Visual Studio jest bezpieczne dla wątków )
  3. Powołanie strtokmodyfikuje stringona pracuje dalej, więc nie może być stosowany na const stringS, const char*S lub ciągami tekstowymi, do tokenize każdy z nich z strtoklub działać na zasadzie stringkto zawartość muszą być zachowane, strmusiałoby zostać skopiowane, a następnie kopia mogłaby być operowany

Zarówno poprzednie metody nie mogą generować tokenized vectorw miejscu, to znaczy bez abstrahując je do funkcji pomocnika nie może zainicjować const vector<string> tokens. Że funkcjonalność i zdolność do zaakceptowania jakiegokolwiek white-space separatora można wykorzystać stosując istream_iterator. Na przykład biorąc pod uwagę: const string str{ "The quick \tbrown \nfox" }możemy to zrobić:

istringstream is{ str };
const vector<string> tokens{ istream_iterator<string>(is), istream_iterator<string>() };

Live Example

Wymagana budowa istringstreamtej opcji ma znacznie większe koszty niż w poprzednich 2 opcje, jednak koszt ten jest zazwyczaj ukryty w koszt stringalokacji.


Jeżeli żadna z powyższych opcji są wystarczająco flexable dla potrzeb tokenizacja, opcja najbardziej elastyczny stosuje regex_token_iteratoroczywiście z tej elastyczności przychodzi większy wydatek, ale znowu jest to prawdopodobnie ukryte w stringkosztach alokacji. Powiedzieć na przykład chcemy tokenize podstawie niewyspecjalizowanych uciekły przecinkami, także jedzenia white-space, biorąc pod uwagę następujące wejścia: const string str{ "The ,qu\\,ick ,\tbrown, fox" }możemy to zrobić:

const regex re{ "\\s*((?:[^\\\\,]|\\\\.)*?)\\s*(?:,|$)" };
const vector<string> tokens{ sregex_token_iterator(cbegin(str), cend(str), re, 1), sregex_token_iterator() };

Live Example

Odpowiedział 26/07/2016 o 16:51
źródło użytkownik

głosy
4

Wiele nadmiernie skomplikowane sugestie tutaj. Spróbuj tego prostego rozwiązania std :: string:

using namespace std;

string someText = ...

string::size_type tokenOff = 0, sepOff = tokenOff;
while (sepOff != string::npos)
{
    sepOff = someText.find(' ', sepOff);
    string::size_type tokenLen = (sepOff == string::npos) ? sepOff : sepOff++ - tokenOff;
    string token = someText.substr(tokenOff, tokenLen);
    if (!token.empty())
        /* do something with token */;
    tokenOff = sepOff;
}
Odpowiedział 01/08/2012 o 06:50
źródło użytkownik

głosy
4

MFC / ATL ma bardzo ładne tokenizera. Od MSDN:

CAtlString str( "%First Second#Third" );
CAtlString resToken;
int curPos= 0;

resToken= str.Tokenize("% #",curPos);
while (resToken != "")
{
   printf("Resulting token: %s\n", resToken);
   resToken= str.Tokenize("% #",curPos);
};

Output

Resulting Token: First
Resulting Token: Second
Resulting Token: Third
Odpowiedział 22/03/2009 o 03:28
źródło użytkownik

głosy
4

Dla prostych rzeczy po prostu korzystać z następujących powodów:

unsigned TokenizeString(const std::string& i_source,
                        const std::string& i_seperators,
                        bool i_discard_empty_tokens,
                        std::vector<std::string>& o_tokens)
{
    unsigned prev_pos = 0;
    unsigned pos = 0;
    unsigned number_of_tokens = 0;
    o_tokens.clear();
    pos = i_source.find_first_of(i_seperators, pos);
    while (pos != std::string::npos)
    {
        std::string token = i_source.substr(prev_pos, pos - prev_pos);
        if (!i_discard_empty_tokens || token != "")
        {
            o_tokens.push_back(i_source.substr(prev_pos, pos - prev_pos));
            number_of_tokens++;
        }

        pos++;
        prev_pos = pos;
        pos = i_source.find_first_of(i_seperators, pos);
    }

    if (prev_pos < i_source.length())
    {
        o_tokens.push_back(i_source.substr(prev_pos));
        number_of_tokens++;
    }

    return number_of_tokens;
}

Tchórzliwy Zastrzeżenie: Piszę oprogramowania do przetwarzania danych w czasie rzeczywistym, w której dane pochodzą z plików binarnych, gniazd lub niektóre wywołanie API (karty I / O, kamery). Nigdy nie używać tej funkcji do czegoś bardziej skomplikowanego lub krytycznych czasowo niż czytanie zewnętrznych plików konfiguracyjnych na starcie.

Odpowiedział 15/09/2008 o 16:28
źródło użytkownik

głosy
4

Myślałem, że to co >>operator na strumieniach smyczkowych miała na celu:

string word; sin >> word;
Odpowiedział 10/09/2008 o 13:43
źródło użytkownik

głosy
4

Jeśli jesteś gotów użyć C, można użyć strtok funkcję. Należy zwrócić uwagę na kwestie wielowątkowości podczas korzystania z niego.

Odpowiedział 10/09/2008 o 13:23
źródło użytkownik

głosy
2

Wydaje mi się, że dziwne ze wszystkimi nam prędkości świadomych frajerów tutaj na SO nikt nie przedstawił wersję, która używa czasu kompilacji wygenerowany spojrzeć w górę tabeli ogranicznika (Przykład realizacji niżej). Korzystanie spojrzeć w górę tabeli i iteratory powinien pokonać std :: regex wydajności, jeśli nie trzeba bić regex, wystarczy użyć go jako swojego standardu C ++ 11 i bardzo elastyczny.

Niektórzy sugerują regex już jednak do tutejszych noobs jest pakowany przykład, że należy zrobić dokładnie to, czego oczekuje OP:

std::vector<std::string> split(std::string::const_iterator it, std::string::const_iterator end, std::regex e = std::regex{"\\w+"}){
    std::smatch m{};
    std::vector<std::string> ret{};
    while (std::regex_search (it,end,m,e)) {
        ret.emplace_back(m.str());              
        std::advance(it, m.position() + m.length()); //next start position = match position + match length
    }
    return ret;
}
std::vector<std::string> split(const std::string &s, std::regex e = std::regex{"\\w+"}){  //comfort version calls flexible version
    return split(s.cbegin(), s.cend(), std::move(e));
}
int main ()
{
    std::string str {"Some people, excluding those present, have been compile time constants - since puberty."};
    auto v = split(str);
    for(const auto&s:v){
        std::cout << s << std::endl;
    }
    std::cout << "crazy version:" << std::endl;
    v = split(str, std::regex{"[^e]+"});  //using e as delim shows flexibility
    for(const auto&s:v){
        std::cout << s << std::endl;
    }
    return 0;
}

Jeśli musimy być szybciej i zaakceptować ograniczenia, że ​​wszystkie znaki muszą być 8 bitów możemy spojrzeć w górę tabeli w czasie kompilacji używając metaprogramowanie:

template<bool...> struct BoolSequence{};        //just here to hold bools
template<char...> struct CharSequence{};        //just here to hold chars
template<typename T, char C> struct Contains;   //generic
template<char First, char... Cs, char Match>    //not first specialization
struct Contains<CharSequence<First, Cs...>,Match> :
    Contains<CharSequence<Cs...>, Match>{};     //strip first and increase index
template<char First, char... Cs>                //is first specialization
struct Contains<CharSequence<First, Cs...>,First>: std::true_type {}; 
template<char Match>                            //not found specialization
struct Contains<CharSequence<>,Match>: std::false_type{};

template<int I, typename T, typename U> 
struct MakeSequence;                            //generic
template<int I, bool... Bs, typename U> 
struct MakeSequence<I,BoolSequence<Bs...>, U>:  //not last
    MakeSequence<I-1, BoolSequence<Contains<U,I-1>::value,Bs...>, U>{};
template<bool... Bs, typename U> 
struct MakeSequence<0,BoolSequence<Bs...>,U>{   //last  
    using Type = BoolSequence<Bs...>;
};
template<typename T> struct BoolASCIITable;
template<bool... Bs> struct BoolASCIITable<BoolSequence<Bs...>>{
    /* could be made constexpr but not yet supported by MSVC */
    static bool isDelim(const char c){
        static const bool table[256] = {Bs...};
        return table[static_cast<int>(c)];
    }   
};
using Delims = CharSequence<'.',',',' ',':','\n'>;  //list your custom delimiters here
using Table = BoolASCIITable<typename MakeSequence<256,BoolSequence<>,Delims>::Type>;

Mając to na miejscu dokonywania getNextTokenfunkcja jest proste:

template<typename T_It>
std::pair<T_It,T_It> getNextToken(T_It begin,T_It end){
    begin = std::find_if(begin,end,std::not1(Table{})); //find first non delim or end
    auto second = std::find_if(begin,end,Table{});      //find first delim or end
    return std::make_pair(begin,second);
}

Korzystanie z niego jest łatwe:

int main() {
    std::string s{"Some people, excluding those present, have been compile time constants - since puberty."};
    auto it = std::begin(s);
    auto end = std::end(s);
    while(it != std::end(s)){
        auto token = getNextToken(it,end);
        std::cout << std::string(token.first,token.second) << std::endl;
        it = token.second;
    }
    return 0;
}

Oto żywy przykład: http://ideone.com/GKtkLQ

Odpowiedział 26/07/2014 o 14:15
źródło użytkownik

głosy
2

Oto podejście, które pozwala kontrolować, czy puste znaczniki są zawarte (jak strsep) lub wyłączone (jak strtok).

#include <string.h> // for strchr and strlen

/*
 * want_empty_tokens==true  : include empty tokens, like strsep()
 * want_empty_tokens==false : exclude empty tokens, like strtok()
 */
std::vector<std::string> tokenize(const char* src,
                                  char delim,
                                  bool want_empty_tokens)
{
  std::vector<std::string> tokens;

  if (src and *src != '\0') // defensive
    while( true )  {
      const char* d = strchr(src, delim);
      size_t len = (d)? d-src : strlen(src);

      if (len or want_empty_tokens)
        tokens.push_back( std::string(src, len) ); // capture token

      if (d) src += len+1; else break;
    }

  return tokens;
}
Odpowiedział 26/10/2012 o 16:14
źródło użytkownik

głosy
1

można skorzystać z boost :: make_find_iterator. Coś podobnego do tego:

template<typename CH>
inline vector< basic_string<CH> > tokenize(
    const basic_string<CH> &Input,
    const basic_string<CH> &Delimiter,
    bool remove_empty_token
    ) {

    typedef typename basic_string<CH>::const_iterator string_iterator_t;
    typedef boost::find_iterator< string_iterator_t > string_find_iterator_t;

    vector< basic_string<CH> > Result;
    string_iterator_t it = Input.begin();
    string_iterator_t it_end = Input.end();
    for(string_find_iterator_t i = boost::make_find_iterator(Input, boost::first_finder(Delimiter, boost::is_equal()));
        i != string_find_iterator_t();
        ++i) {
        if(remove_empty_token){
            if(it != i->begin())
                Result.push_back(basic_string<CH>(it,i->begin()));
        }
        else
            Result.push_back(basic_string<CH>(it,i->begin()));
        it = i->end();
    }
    if(it != it_end)
        Result.push_back(basic_string<CH>(it,it_end));

    return Result;
}
Odpowiedział 03/08/2011 o 07:58
źródło użytkownik

głosy
1

Nie ma bezpośredni sposób to zrobić. Patrz kod źródłowy projektu kodu , aby dowiedzieć się, jak zbudować klasę do tego.

Odpowiedział 10/09/2008 o 13:14
źródło użytkownik

głosy
0

Oto mój Swiss® scyzoryk z String-tokenizers do dzielenia się ciągi białymi znakami, które stanowią pojedyncze i podwójne cytując owiniętych strun, a także usuwania te znaki z wyników. Kiedyś RegexBuddy 4.x do generowania najbardziej Kodeksu-urywek, ale dodałem niestandardową obsługę do odpędzania cytaty i kilka innych rzeczy.

#include <string>
#include <locale>
#include <regex>

std::vector<std::wstring> tokenize_string(std::wstring string_to_tokenize) {
    std::vector<std::wstring> tokens;

    std::wregex re(LR"(("[^"]*"|'[^']*'|[^"' ]+))", std::regex_constants::collate);

    std::wsregex_iterator next( string_to_tokenize.begin(),
                                string_to_tokenize.end(),
                                re,
                                std::regex_constants::match_not_null );

    std::wsregex_iterator end;
    const wchar_t single_quote = L'\'';
    const wchar_t double_quote = L'\"';
    while ( next != end ) {
        std::wsmatch match = *next;
        const std::wstring token = match.str( 0 );
        next++;

        if (token.length() > 2 && (token.front() == double_quote || token.front() == single_quote))
            tokens.emplace_back( std::wstring(token.begin()+1, token.begin()+token.length()-1) );
        else
            tokens.emplace_back(token);
    }
    return tokens;
}
Odpowiedział 21/09/2018 o 03:28
źródło użytkownik

głosy
0

Wiem, że to pytanie jest już odpowiedź, ale chcę do tego przyczynić. Może moje rozwiązanie jest nieco proste, ale to jest to, co ja przyszedłem z:

vector<string> get_words(string const& text)
{
    vector<string> result;
    string tmp = text;

    size_t first_pos = 0;
    size_t second_pos = tmp.find(" ");;

    while (second_pos != string::npos)
    {
        if (first_pos != second_pos)
        {
            string word = tmp.substr(first_pos, second_pos - first_pos);
            result.push_back(word);
        }
        tmp = tmp.substr(second_pos + 1);
        second_pos = tmp.find(" ");
    }

    return result;
}

Proszę o komentarz, jeśli istnieje lepsze podejście do czegoś w moim kodu lub jeśli coś jest nie tak.

Odpowiedział 09/05/2018 o 07:12
źródło użytkownik

głosy
0

Zrobiłem Lexer / tokenizera wcześniej przy wykorzystaniu tylko standardowych bibliotek. Oto kod:

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

using namespace std;

string seps(string& s) {
    if (!s.size()) return "";
    stringstream ss;
    ss << s[0];
    for (int i = 1; i < s.size(); i++) {
        ss << '|' << s[i];
    }
    return ss.str();
}

void Tokenize(string& str, vector<string>& tokens, const string& delimiters = " ")
{
    seps(str);

    // Skip delimiters at beginning.
    string::size_type lastPos = str.find_first_not_of(delimiters, 0);
    // Find first "non-delimiter".
    string::size_type pos = str.find_first_of(delimiters, lastPos);

    while (string::npos != pos || string::npos != lastPos)
    {
        // Found a token, add it to the vector.
        tokens.push_back(str.substr(lastPos, pos - lastPos));
        // Skip delimiters.  Note the "not_of"
        lastPos = str.find_first_not_of(delimiters, pos);
        // Find next "non-delimiter"
        pos = str.find_first_of(delimiters, lastPos);
    }
}

int main(int argc, char *argv[])
{
    vector<string> t;
    string s = "Tokens for everyone!";

    Tokenize(s, t, "|");

    for (auto c : t)
        cout << c << endl;

    system("pause");

    return 0;
}
Odpowiedział 15/01/2015 o 17:13
źródło użytkownik

głosy
0

Szukałem sposobu, aby podzielić ciąg przez separator o dowolnej długości, więc zacząłem pisać go od nowa, ponieważ istniejące rozwiązania nie pasował mi.

Oto mój mały algorytm, za pomocą tylko STL:

//use like this
//std::vector<std::wstring> vec = Split<std::wstring> (L"Hello##world##!", L"##");

template <typename valueType>
static std::vector <valueType> Split (valueType text, const valueType& delimiter)
{
    std::vector <valueType> tokens;
    size_t pos = 0;
    valueType token;

    while ((pos = text.find(delimiter)) != valueType::npos) 
    {
        token = text.substr(0, pos);
        tokens.push_back (token);
        text.erase(0, pos + delimiter.length());
    }
    tokens.push_back (text);

    return tokens;
}

Może być stosowany z separatorem o dowolnej długości i formie, o ile Przetestowałem. Instancję albo sznurkiem lub typu wstring.

Cały algorytm robi to wyszukuje ogranicznika, dostaje część napisu, który jest do separatora, usuwa separator i przeszukuje ponownie, dopóki nie znajdzie się nic więcej.

Mam nadzieję, że to pomoże.

Odpowiedział 17/03/2014 o 17:54
źródło użytkownik

głosy
0
/// split a string into multiple sub strings, based on a separator string
/// for example, if separator="::",
///
/// s = "abc" -> "abc"
///
/// s = "abc::def xy::st:" -> "abc", "def xy" and "st:",
///
/// s = "::abc::" -> "abc"
///
/// s = "::" -> NO sub strings found
///
/// s = "" -> NO sub strings found
///
/// then append the sub-strings to the end of the vector v.
/// 
/// the idea comes from the findUrls() function of "Accelerated C++", chapt7,
/// findurls.cpp
///
void split(const string& s, const string& sep, vector<string>& v)
{
    typedef string::const_iterator iter;
    iter b = s.begin(), e = s.end(), i;
    iter sep_b = sep.begin(), sep_e = sep.end();

    // search through s
    while (b != e){
        i = search(b, e, sep_b, sep_e);

        // no more separator found
        if (i == e){
            // it's not an empty string
            if (b != e)
                v.push_back(string(b, e));
            break;
        }
        else if (i == b){
            // the separator is found and right at the beginning
            // in this case, we need to move on and search for the
            // next separator
            b = i + sep.length();
        }
        else{
            // found the separator
            v.push_back(string(b, i));
            b = i;
        }
    }
}

Biblioteka Boost jest dobra, ale nie zawsze są dostępne. Robi tego typu rzeczy ręcznie jest również dobrym ćwiczeniem mózgu. Tu wystarczy użyć algorytmu std :: search () z STL, patrz powyższy kod.

Odpowiedział 25/02/2014 o 07:40
źródło użytkownik

głosy
0

Prosty kod C ++ (C ++ norma 98), akceptuje wiele ograniczników (określona w std :: string), używa tylko wektory, sznurki i iteratory.

#include <iostream>
#include <vector>
#include <string>
#include <stdexcept> 

std::vector<std::string> 
split(const std::string& str, const std::string& delim){
    std::vector<std::string> result;
    if (str.empty())
        throw std::runtime_error("Can not tokenize an empty string!");
    std::string::const_iterator begin, str_it;
    begin = str_it = str.begin(); 
    do {
        while (delim.find(*str_it) == std::string::npos && str_it != str.end())
            str_it++; // find the position of the first delimiter in str
        std::string token = std::string(begin, str_it); // grab the token
        if (!token.empty()) // empty token only when str starts with a delimiter
            result.push_back(token); // push the token into a vector<string>
        while (delim.find(*str_it) != std::string::npos && str_it != str.end())
            str_it++; // ignore the additional consecutive delimiters
        begin = str_it; // process the remaining tokens
        } while (str_it != str.end());
    return result;
}

int main() {
    std::string test_string = ".this is.a.../.simple;;test;;;END";
    std::string delim = "; ./"; // string containing the delimiters
    std::vector<std::string> tokens = split(test_string, delim);           
    for (std::vector<std::string>::const_iterator it = tokens.begin(); 
        it != tokens.end(); it++)
            std::cout << *it << std::endl;
}
Odpowiedział 15/12/2013 o 02:09
źródło użytkownik

głosy
0

boost::tokenizerJest twoim przyjacielem, ale rozważyć swój kod Portable z odniesieniem do internacjonalizacji (i18n) zagadnień za pomocą wstring/ wchar_tzamiast Legacy string/ chartypy.

#include <iostream>
#include <boost/tokenizer.hpp>
#include <string>

using namespace std;
using namespace boost;

typedef tokenizer<char_separator<wchar_t>,
                  wstring::const_iterator, wstring> Tok;

int main()
{
  wstring s;
  while (getline(wcin, s)) {
    char_separator<wchar_t> sep(L" "); // list of separator characters
    Tok tok(s, sep);
    for (Tok::iterator beg = tok.begin(); beg != tok.end(); ++beg) {
      wcout << *beg << L"\t"; // output (or store in vector)
    }
    wcout << L"\n";
  }
  return 0;
}
Odpowiedział 16/07/2012 o 02:14
źródło użytkownik

głosy
0

Jeśli maksymalna długość ciągu wejściowego do tokenized jest znany, można wykorzystać to i realizować bardzo szybką wersję. Ja szkicowania podstawową ideę poniżej, który został zainspirowany zarówno strtok () i „tablicę przyrostek” -data struktura opisana Jon Bentley „Programowanie Perls” wydanie 2, rozdział 15. C ++ klasa w tym przypadku tylko daje pewną organizację i wygodę użytkowania. Realizacja pokazany można łatwo rozszerzyć do usuwania początkowe i końcowe białe znaki na żetony.

Zasadniczo można zastąpić znaki oddzielające ze sznurkiem-kończące „\ 0'-znaków i ustawić wskaźniki do tokenów withing zmodyfikowanego łańcucha. W skrajnym przypadku, gdy łańcuch składa się tylko z separatorami, dostaje ciąg długości plus 1 wynikającej pustych znaków. Jest to praktyczne, aby powielić ciąg zostać zmodyfikowany.

nagłówek pliku:

class TextLineSplitter
{
public:

    TextLineSplitter( const size_t max_line_len );

    ~TextLineSplitter();

    void            SplitLine( const char *line,
                               const char sep_char = ',',
                             );

    inline size_t   NumTokens( void ) const
    {
        return mNumTokens;
    }

    const char *    GetToken( const size_t token_idx ) const
    {
        assert( token_idx < mNumTokens );
        return mTokens[ token_idx ];
    }

private:
    const size_t    mStorageSize;

    char           *mBuff;
    char          **mTokens;
    size_t          mNumTokens;

    inline void     ResetContent( void )
    {
        memset( mBuff, 0, mStorageSize );
        // mark all items as empty:
        memset( mTokens, 0, mStorageSize * sizeof( char* ) );
        // reset counter for found items:
        mNumTokens = 0L;
    }
};

Plik Implementattion:

TextLineSplitter::TextLineSplitter( const size_t max_line_len ):
    mStorageSize ( max_line_len + 1L )
{
    // allocate memory
    mBuff   = new char  [ mStorageSize ];
    mTokens = new char* [ mStorageSize ];

    ResetContent();
}

TextLineSplitter::~TextLineSplitter()
{
    delete [] mBuff;
    delete [] mTokens;
}


void TextLineSplitter::SplitLine( const char *line,
                                  const char sep_char   /* = ',' */,
                                )
{
    assert( sep_char != '\0' );

    ResetContent();
    strncpy( mBuff, line, mMaxLineLen );

    size_t idx       = 0L; // running index for characters

    do
    {
        assert( idx < mStorageSize );

        const char chr = line[ idx ]; // retrieve current character

        if( mTokens[ mNumTokens ] == NULL )
        {
            mTokens[ mNumTokens ] = &mBuff[ idx ];
        } // if

        if( chr == sep_char || chr == '\0' )
        { // item or line finished
            // overwrite separator with a 0-terminating character:
            mBuff[ idx ] = '\0';
            // count-up items:
            mNumTokens ++;
        } // if

    } while( line[ idx++ ] );
}

Scenariusz użycia może być:

// create an instance capable of splitting strings up to 1000 chars long:
TextLineSplitter spl( 1000 );
spl.SplitLine( "Item1,,Item2,Item3" );
for( size_t i = 0; i < spl.NumTokens(); i++ )
{
    printf( "%s\n", spl.GetToken( i ) );
}

wydajność:

Item1

Item2
Item3
Odpowiedział 15/05/2011 o 21:47
źródło użytkownik

głosy
-3

Ta prosta pętla do tokenise tylko standardowych plików bibliotecznych

#include <iostream.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <conio.h>
class word
    {
     public:
     char w[20];
     word()
      {
        for(int j=0;j<=20;j++)
        {w[j]='\0';
      }
   }



};

void main()
  {
    int i=1,n=0,j=0,k=0,m=1;
    char input[100];
    word ww[100];
    gets(input);

    n=strlen(input);


    for(i=0;i<=m;i++)
      {
        if(context[i]!=' ')
         {
            ww[k].w[j]=context[i];
            j++;

         }
         else
        {
         k++;
         j=0;
         m++;
        }

   }
 }
Odpowiedział 19/05/2013 o 14:42
źródło użytkownik

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more