Bir dizenin sözcüklerini nasıl yineleyebilirim?

Bir dizenin kelimeleri üzerinde yinelemeye çalışıyorum.

Dizenin boşlukla ayrılmış kelimelerden oluştuğu varsayılabilir.

C string fonksiyonları veya karakter manipülasyonu / erişimi bu tür ilgilenmiyorum unutmayın. Ayrıca, cevabınızdaki verim üzerinde zarafete öncelik verin.

Şu anda sahip olduğum en iyi çözüm:

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

using namespace std;

int main()
{
    string s = "Somewhere down the road";
    istringstream iss(s);

    do
    {
        string subs;
        iss >> subs;
        cout << "Substring: " << subs << endl;
    } while (iss);
}

Bunu yapmanın daha zarif bir yolu var mı?

Değer için, sadece standart kütüphane tesislerine dayanarak bir giriş dizesinden jeton çıkarmanın başka bir yolu. Bu, STL tasarımının arkasındaki güç ve zarafetin bir örneğidir.

#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <iterator>

int main() {
    using namespace std;
    string sentence = "And I feel fine...";
    istringstream iss(sentence);
    copy(istream_iterator<string>(iss),
         istream_iterator<string>(),
         ostream_iterator<string>(cout, "\n"));
}

Çıkarılan belirteçleri bir çıkış akışına kopyalamak yerine, aynı genel copyalgoritmayı kullanarak bunları bir kaba ekleyebiliriz .

vector<string> tokens;
copy(istream_iterator<string>(iss),
     istream_iterator<string>(),
     back_inserter(tokens));

... veya vectordoğrudan oluşturun :

vector<string> tokens{istream_iterator<string>{iss},
                      istream_iterator<string>{}};

Ben bir sınırlayıcı tarafından dize bölmek için kullanın. Birincisi sonuçları önceden oluşturulmuş bir vektöre koyar, ikincisi yeni bir vektör döndürür.

#include <string>
#include <sstream>
#include <vector>
#include <iterator>

template <typename Out>
void split(const std::string &s, char delim, Out result) {
    std::istringstream iss(s);
    std::string item;
    while (std::getline(iss, item, delim)) {
        *result++ = item;
    }
}

std::vector<std::string> split(const std::string &s, char delim) {
    std::vector<std::string> elems;
    split(s, delim, std::back_inserter(elems));
    return elems;
}

Bu çözümün boş belirteçleri atlamadığını unutmayın, bu nedenle aşağıdakilerden biri boş olan 4 öğe bulacaktır:

std::vector<std::string> x = split("one:two::three", ':');

Boost kullanarak olası bir çözüm şunlar olabilir:

#include <boost/algorithm/string.hpp>
std::vector<std::string> strs;
boost::split(strs, "string to split", boost::is_any_of("\t "));

Bu yaklaşım, stringstreamyaklaşımdan bile daha hızlı olabilir . Ve bu genel bir şablon işlevi olduğundan, her türlü sınırlayıcıyı kullanarak diğer dizeleri (wchar, vb. Veya UTF-8) bölmek için kullanılabilir.

Ayrıntılar için belgelere bakın.

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

int main()
{
    std::string str("Split me by whitespaces");
    std::string buf;                 // Have a buffer string
    std::stringstream ss(str);       // Insert the string into a stream

    std::vector<std::string> tokens; // Create vector to hold our words

    while (ss >> buf)
        tokens.push_back(buf);

    return 0;
}

Kod boyutu için tüm verimliliği feda etmek ve "şık" bir zarafet türü olarak görmek için iyi oturmayanlar için, aşağıdakiler tatlı bir noktaya çarpmalıdır (ve ben şablon konteyner sınıfının inanılmaz zarif bir ek olduğunu düşünüyorum.):

template < class ContainerT >
void tokenize(const std::string& str, ContainerT& tokens,
              const std::string& delimiters = " ", bool trimEmpty = false)
{
   std::string::size_type pos, lastPos = 0, length = str.length();

   using value_type = typename ContainerT::value_type;
   using size_type  = typename ContainerT::size_type;

   while(lastPos < length + 1)
   {
      pos = str.find_first_of(delimiters, lastPos);
      if(pos == std::string::npos)
      {
         pos = length;
      }

      if(pos != lastPos || !trimEmpty)
         tokens.push_back(value_type(str.data()+lastPos,
               (size_type)pos-lastPos ));

      lastPos = pos + 1;
   }
}

Genellikle kullanmayı tercih std::vector<std::string>benim ikinci parametre (aynı tip ContainerT) ... ama list<>yolu daha hızlı olduğu vector<>doğrudan erişim gerekmediğinde için ve benzeri hatta kendi dize sınıf ve kullanım şey oluşturabilir std::list<subString>nerede subStringinanılmaz hız için herhangi bir kopyasını yapmaz artışlar.

Bu sayfadaki en hızlı tokenizden iki kat daha hızlı ve diğerlerinden neredeyse 5 kat daha hızlı. Ayrıca mükemmel parametre türleriyle, ek hız artışları için tüm dize ve liste kopyalarını kaldırabilirsiniz.

Ek olarak (son derece verimsiz) sonucun geri dönüşünü yapmaz, bunun yerine jetonları referans olarak geçirir, böylece dilerseniz birden fazla çağrı kullanarak jeton oluşturmanıza izin verir.

Son olarak, son isteğe bağlı bir parametre aracılığıyla sonuçlardan boş belirteçlerin kırpılıp kırpılmayacağını belirlemenizi sağlar.

Tek ihtiyacı olan std::string... gerisi isteğe bağlı. Akışları veya destek kütüphanesini kullanmaz, ancak bu yabancı türlerin bazılarını doğal olarak kabul edebilecek kadar esnektir.

İşte başka bir çözüm. Kompakt ve oldukça verimli:

std::vector<std::string> split(const std::string &text, char sep) {
  std::vector<std::string> tokens;
  std::size_t start = 0, end = 0;
  while ((end = text.find(sep, start)) != std::string::npos) {
    tokens.push_back(text.substr(start, end - start));
    start = end + 1;
  }
  tokens.push_back(text.substr(start));
  return tokens;
}

Dize ayırıcılarını, geniş telleri, vb. İşlemek için kolayca değiştirilebilir.

Bölmenin ""tek bir boş dize ve bölünmenin ","(yani sep) iki boş dizeyle sonuçlandığını unutmayın .

Boş belirteçleri atlamak için kolayca genişletilebilir:

std::vector<std::string> split(const std::string &text, char sep) {
    std::vector<std::string> tokens;
    std::size_t start = 0, end = 0;
    while ((end = text.find(sep, start)) != std::string::npos) {
        if (end != start) {
          tokens.push_back(text.substr(start, end - start));
        }
        start = end + 1;
    }
    if (end != start) {
       tokens.push_back(text.substr(start));
    }
    return tokens;
}

Boş simgeleri atlarken bir dizeyi birden çok sınırlayıcıya bölmek isteniyorsa, bu sürüm kullanılabilir:

std::vector<std::string> split(const std::string& text, const std::string& delims)
{
    std::vector<std::string> tokens;
    std::size_t start = text.find_first_not_of(delims), end = 0;

    while((end = text.find_first_of(delims, start)) != std::string::npos)
    {
        tokens.push_back(text.substr(start, end - start));
        start = text.find_first_not_of(delims, end);
    }
    if(start != std::string::npos)
        tokens.push_back(text.substr(start));

    return tokens;
}

Bu bir dizeden yineleme yapmak için en sevdiğim yol Kelime başına ne istersen yapabilirsin.

string line = "a line of text to iterate through";
string word;

istringstream iss(line, istringstream::in);

while( iss >> word )     
{
    // Do something on `word` here...
}

Bu yığın taşması sorusuna benzer C ++ bir dize nasıl tokenize edebilirim? .

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

using namespace std;
using namespace boost;

int main(int argc, char** argv)
{
    string text = "token  test\tstring";

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

Sonuçları bir vektör içine koyar, bir dize bir delim olarak destekler ve boş değerleri tutmak üzerinde kontrol sağlar çünkü aşağıdaki gibi. Ancak, o zaman iyi görünmüyor.

#include <ostream>
#include <string>
#include <vector>
#include <algorithm>
#include <iterator>
using namespace std;

vector<string> split(const string& s, const string& delim, const bool keep_empty = true) {
    vector<string> result;
    if (delim.empty()) {
        result.push_back(s);
        return result;
    }
    string::const_iterator substart = s.begin(), subend;
    while (true) {
        subend = search(substart, s.end(), delim.begin(), delim.end());
        string temp(substart, subend);
        if (keep_empty || !temp.empty()) {
            result.push_back(temp);
        }
        if (subend == s.end()) {
            break;
        }
        substart = subend + delim.size();
    }
    return result;
}

int main() {
    const vector<string> words = split("So close no matter how far", " ");
    copy(words.begin(), words.end(), ostream_iterator<string>(cout, "\n"));
}

Elbette, Boost'un split()kısmen böyle çalışan bir modeli var. Ve eğer 'beyaz boşluk' ile, gerçekten Boost'un split ile is_any_of()harika bir şekilde çalıştığı herhangi bir beyaz boşluk demek istersiniz .

STL'nin halihazırda böyle bir yöntemi yoktur.

Ancak, üyeyi kullanarak C'nin strtok()işlevini kullanabilir std::string::c_str()veya kendiniz yazabilirsiniz. Hızlı bir Google aramasından sonra bulduğum bir kod örneği ( "STL string split" ):

void Tokenize(const string& str,
              vector<string>& tokens,
              const string& delimiters = " ")
{
    // 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);
    }
}

Alındığı yer: http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html

Kod örneği hakkında sorularınız varsa, bir yorum bırakın ve ben açıklayacağım.

Ve sadece typedefyinelenen bir yineleyici uygulamadığı veya aşırı yüklenmediği için <<operatör kötü kod olduğu anlamına gelmez. C fonksiyonlarını oldukça sık kullanıyorum. Örneğin, printfve scanfher ikisi birden std::cinve std::cout(önemli ölçüde) daha hızlıdır , fopensözdizimi ikili türler için çok daha dostudur ve ayrıca daha küçük EXE'ler üretme eğilimindedir.

Bu "Performans üzerinde zarafet" anlaşmasında satılmayın .

İşte bir bölünmüş fonksiyon:

• jenerik
• standart C ++ kullanır (destek yok)
• birden fazla sınırlayıcı kabul eder

• boş belirteçleri yok sayar (kolayca değiştirilebilir)

  template<typename T>
  vector<T> 
  split(const T & str, const T & delimiters) {
      vector<T> v;
      typename T::size_type start = 0;
      auto pos = str.find_first_of(delimiters, start);
      while(pos != T::npos) {
          if(pos != start) // ignore empty tokens
              v.emplace_back(str, start, pos - start);
          start = pos + 1;
          pos = str.find_first_of(delimiters, start);
      }
      if(start < str.length()) // ignore trailing delimiter
          v.emplace_back(str, start, str.length() - start); // add what's left of the string
      return v;
  }

Örnek kullanım:

    vector<string> v = split<string>("Hello, there; World", ";,");
    vector<wstring> v = split<wstring>(L"Hello, there; World", L";,");

Bu soruna 2 satır çözüm var:

char sep = ' ';
std::string s="1 This is an example";

for(size_t p=0, q=0; p!=s.npos; p=q)
  std::cout << s.substr(p+(p!=0), (q=s.find(sep, p+1))-p-(p!=0)) << std::endl;

Daha sonra yazdırmak yerine bir vektöre koyabilirsiniz.

Yine başka bir esnek ve hızlı yol

template<typename Operator>
void tokenize(Operator& op, const char* input, const char* delimiters) {
  const char* s = input;
  const char* e = s;
  while (*e != 0) {
    e = s;
    while (*e != 0 && strchr(delimiters, *e) == 0) ++e;
    if (e - s > 0) {
      op(s, e - s);
    }
    s = e + 1;
  }
}

Bir dizgi vektörü ile kullanmak için (Düzenle: Birisi STL sınıflarını devralmayacağına dikkat çektiğinden ... hrmf;)):

template<class ContainerType>
class Appender {
public:
  Appender(ContainerType& container) : container_(container) {;}
  void operator() (const char* s, unsigned length) { 
    container_.push_back(std::string(s,length));
  }
private:
  ContainerType& container_;
};

std::vector<std::string> strVector;
Appender v(strVector);
tokenize(v, "A number of words to be tokenized", " \t");

Bu kadar! Bu, tokenizörü kullanmanın sadece bir yoludur, tıpkı kelimeleri nasıl sayacağınız gibi:

class WordCounter {
public:
  WordCounter() : noOfWords(0) {}
  void operator() (const char*, unsigned) {
    ++noOfWords;
  }
  unsigned noOfWords;
};

WordCounter wc;
tokenize(wc, "A number of words to be counted", " \t"); 
ASSERT( wc.noOfWords == 7 );

Hayal gücü ile sınırlı;)

İşte sadece standart normal ifade kitaplığını kullanan basit bir çözüm

#include <regex>
#include <string>
#include <vector>

std::vector<string> Tokenize( const string str, const std::regex regex )
{
    using namespace std;

    std::vector<string> result;

    sregex_token_iterator it( str.begin(), str.end(), regex, -1 );
    sregex_token_iterator reg_end;

    for ( ; it != reg_end; ++it ) {
        if ( !it->str().empty() ) //token could be empty:check
            result.emplace_back( it->str() );
    }

    return result;
}

Normal ifade bağımsız değişkeni birden çok bağımsız değişkeni (boşluk, virgül vb.) Denetlemeye izin verir

Ben genellikle sadece boşluk ve virgül üzerinde bölmek için kontrol, bu yüzden de bu varsayılan işlevi var:

std::vector<string> TokenizeDefault( const string str )
{
    using namespace std;

    regex re( "[\\s,]+" );

    return Tokenize( str, re );
}

"[\\s,]+"Boşluklar (denetler \\s) ve virgül ( ,).

wstringBunun yerine bölmek istiyorsanız string,

• hepsini std::regexdeğiştirstd::wregex
• hepsini sregex_token_iteratordeğiştirwsregex_token_iterator

Ayrıca, derleyicinize bağlı olarak dize bağımsız değişkenini referans olarak almak isteyebilirsiniz.

Sahip olduğunuz gibi kullanmak std::stringstreammükemmel çalışıyor ve tam olarak ne istediğinizi yapın. Sadece bir şeyler yapmanın farklı yollarını arıyorsanız, std::find()/ std::find_first_of()ve tuşlarını kullanabilirsiniz std::string::substr().

İşte bir örnek:

#include <iostream>
#include <string>

int main()
{
    std::string s("Somewhere down the road");
    std::string::size_type prev_pos = 0, pos = 0;

    while( (pos = s.find(' ', pos)) != std::string::npos )
    {
        std::string substring( s.substr(prev_pos, pos-prev_pos) );

        std::cout << substring << '\n';

        prev_pos = ++pos;
    }

    std::string substring( s.substr(prev_pos, pos-prev_pos) ); // Last word
    std::cout << substring << '\n';

    return 0;
}

Boost'u kullanmak istiyorsanız, ancak tüm dizeyi sınırlayıcı olarak kullanmak istiyorsanız (daha önce önerilen çözümlerin çoğunda olduğu gibi tek karakterler yerine) boost_split_iterator.

Uygun şablon içeren örnek kod:

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

template<typename _OutputIterator>
inline void split(
    const std::string& str, 
    const std::string& delim, 
    _OutputIterator result)
{
    using namespace boost::algorithm;
    typedef split_iterator<std::string::const_iterator> It;

    for(It iter=make_split_iterator(str, first_finder(delim, is_equal()));
            iter!=It();
            ++iter)
    {
        *(result++) = boost::copy_range<std::string>(*iter);
    }
}

int main(int argc, char* argv[])
{
    using namespace std;

    vector<string> splitted;
    split("HelloFOOworldFOO!", "FOO", back_inserter(splitted));

    // or directly to console, for example
    split("HelloFOOworldFOO!", "FOO", ostream_iterator<string>(cout, "\n"));
    return 0;
}

Heres normal regex kütüphanesini kullanan bir regex çözümü içerir. (Biraz paslıyım, bu yüzden birkaç sözdizimi hatası olabilir, ancak en azından genel fikir budur)

#include <regex.h>
#include <string.h>
#include <vector.h>

using namespace std;

vector<string> split(string s){
    regex r ("\\w+"); //regex matches whole words, (greedy, so no fragment words)
    regex_iterator<string::iterator> rit ( s.begin(), s.end(), r );
    regex_iterator<string::iterator> rend; //iterators to iterate thru words
    vector<string> result<regex_iterator>(rit, rend);
    return result;  //iterates through the matches to fill the vector
}

Adlı bir işlev var strtok.

#include<string>
using namespace std;

vector<string> split(char* str,const char* delim)
{
    char* saveptr;
    char* token = strtok_r(str,delim,&saveptr);

    vector<string> result;

    while(token != NULL)
    {
        result.push_back(token);
        token = strtok_r(NULL,delim,&saveptr);
    }
    return result;
}

Stringstream olmayan uzay sembollerle dizesini ayrıştırmak gerekiyorsa uygun olabilir:

string s = "Name:JAck; Spouse:Susan; ...";
string dummy, name, spouse;

istringstream iss(s);
getline(iss, dummy, ':');
getline(iss, name, ';');
getline(iss, dummy, ':');
getline(iss, spouse, ';')

Şimdiye kadar bir tane kullanılan Boost , ama bu geldi yüzden, buna bağlı olmayan bir şeyi gerekli:

static void Split(std::vector<std::string>& lst, const std::string& input, const std::string& separators, bool remove_empty = true)
{
    std::ostringstream word;
    for (size_t n = 0; n < input.size(); ++n)
    {
        if (std::string::npos == separators.find(input[n]))
            word << input[n];
        else
        {
            if (!word.str().empty() || !remove_empty)
                lst.push_back(word.str());
            word.str("");
        }
    }
    if (!word.str().empty() || !remove_empty)
        lst.push_back(word.str());
}

İyi bir nokta, içinde separatorsbirden fazla karakter geçirebilmenizdir.

Ben strtok kullanarak kendi haddelenmiş ve bir dize bölmek için boost kullandım. Bulduğum en iyi yöntem C ++ String Toolkit Library'dir . İnanılmaz derecede esnek ve hızlı.

#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 s("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 s("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;
}

Araç seti, bu basit örneğin göstereceğinden çok daha fazla esnekliğe sahiptir, ancak bir dizeyi yararlı öğelere ayrıştırmadaki faydası inanılmazdır.

Kısa ve zarif

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

vector<string> split(string data, string token)
{
    vector<string> output;
    size_t pos = string::npos; // size_t to avoid improbable overflow
    do
    {
        pos = data.find(token);
        output.push_back(data.substr(0, pos));
        if (string::npos != pos)
            data = data.substr(pos + token.size());
    } while (string::npos != pos);
    return output;
}

sınırlayıcı olarak herhangi bir dizeyi kullanabilir, ayrıca ikili verilerle kullanılabilir (std :: string, null'ler dahil ikili verileri destekler)

kullanarak:

auto a = split("this!!is!!!example!string", "!!");

çıktı:

this
is
!example!string

Bunu yaptım çünkü dizeleri ve c tabanlı dizeleri bölmek için kolay bir yola ihtiyacım vardı ... Umarım başka biri de faydalı olabilir. Ayrıca jetonlara dayanmaz ve alanları sınırlayıcı olarak kullanabilirsiniz, bu da ihtiyacım olan başka bir anahtar.

Eminim zarafetini daha da artırmak için yapılabilecek iyileştirmeler var ve lütfen elbette yapın

StringSplitter.hpp:

#include <vector>
#include <iostream>
#include <string.h>

using namespace std;

class StringSplit
{
private:
    void copy_fragment(char*, char*, char*);
    void copy_fragment(char*, char*, char);
    bool match_fragment(char*, char*, int);
    int untilnextdelim(char*, char);
    int untilnextdelim(char*, char*);
    void assimilate(char*, char);
    void assimilate(char*, char*);
    bool string_contains(char*, char*);
    long calc_string_size(char*);
    void copy_string(char*, char*);

public:
    vector<char*> split_cstr(char);
    vector<char*> split_cstr(char*);
    vector<string> split_string(char);
    vector<string> split_string(char*);
    char* String;
    bool do_string;
    bool keep_empty;
    vector<char*> Container;
    vector<string> ContainerS;

    StringSplit(char * in)
    {
        String = in;
    }

    StringSplit(string in)
    {
        size_t len = calc_string_size((char*)in.c_str());
        String = new char[len + 1];
        memset(String, 0, len + 1);
        copy_string(String, (char*)in.c_str());
        do_string = true;
    }

    ~StringSplit()
    {
        for (int i = 0; i < Container.size(); i++)
        {
            if (Container[i] != NULL)
            {
                delete[] Container[i];
            }
        }
        if (do_string)
        {
            delete[] String;
        }
    }
};

StringSplitter.cpp:

#include <string.h>
#include <iostream>
#include <vector>
#include "StringSplit.hpp"

using namespace std;

void StringSplit::assimilate(char*src, char delim)
{
    int until = untilnextdelim(src, delim);
    if (until > 0)
    {
        char * temp = new char[until + 1];
        memset(temp, 0, until + 1);
        copy_fragment(temp, src, delim);
        if (keep_empty || *temp != 0)
        {
            if (!do_string)
            {
                Container.push_back(temp);
            }
            else
            {
                string x = temp;
                ContainerS.push_back(x);
            }

        }
        else
        {
            delete[] temp;
        }
    }
}

void StringSplit::assimilate(char*src, char* delim)
{
    int until = untilnextdelim(src, delim);
    if (until > 0)
    {
        char * temp = new char[until + 1];
        memset(temp, 0, until + 1);
        copy_fragment(temp, src, delim);
        if (keep_empty || *temp != 0)
        {
            if (!do_string)
            {
                Container.push_back(temp);
            }
            else
            {
                string x = temp;
                ContainerS.push_back(x);
            }
        }
        else
        {
            delete[] temp;
        }
    }
}

long StringSplit::calc_string_size(char* _in)
{
    long i = 0;
    while (*_in++)
    {
        i++;
    }
    return i;
}

bool StringSplit::string_contains(char* haystack, char* needle)
{
    size_t len = calc_string_size(needle);
    size_t lenh = calc_string_size(haystack);
    while (lenh--)
    {
        if (match_fragment(haystack + lenh, needle, len))
        {
            return true;
        }
    }
    return false;
}

bool StringSplit::match_fragment(char* _src, char* cmp, int len)
{
    while (len--)
    {
        if (*(_src + len) != *(cmp + len))
        {
            return false;
        }
    }
    return true;
}

int StringSplit::untilnextdelim(char* _in, char delim)
{
    size_t len = calc_string_size(_in);
    if (*_in == delim)
    {
        _in += 1;
        return len - 1;
    }

    int c = 0;
    while (*(_in + c) != delim && c < len)
    {
        c++;
    }

    return c;
}

int StringSplit::untilnextdelim(char* _in, char* delim)
{
    int s = calc_string_size(delim);
    int c = 1 + s;

    if (!string_contains(_in, delim))
    {
        return calc_string_size(_in);
    }
    else if (match_fragment(_in, delim, s))
    {
        _in += s;
        return calc_string_size(_in);
    }

    while (!match_fragment(_in + c, delim, s))
    {
        c++;
    }

    return c;
}

void StringSplit::copy_fragment(char* dest, char* src, char delim)
{
    if (*src == delim)
    {
        src++;
    }

    int c = 0;
    while (*(src + c) != delim && *(src + c))
    {
        *(dest + c) = *(src + c);
        c++;
    }
    *(dest + c) = 0;
}

void StringSplit::copy_string(char* dest, char* src)
{
    int i = 0;
    while (*(src + i))
    {
        *(dest + i) = *(src + i);
        i++;
    }
}

void StringSplit::copy_fragment(char* dest, char* src, char* delim)
{
    size_t len = calc_string_size(delim);
    size_t lens = calc_string_size(src);

    if (match_fragment(src, delim, len))
    {
        src += len;
        lens -= len;
    }

    int c = 0;
    while (!match_fragment(src + c, delim, len) && (c < lens))
    {
        *(dest + c) = *(src + c);
        c++;
    }
    *(dest + c) = 0;
}

vector<char*> StringSplit::split_cstr(char Delimiter)
{
    int i = 0;
    while (*String)
    {
        if (*String != Delimiter && i == 0)
        {
            assimilate(String, Delimiter);
        }
        if (*String == Delimiter)
        {
            assimilate(String, Delimiter);
        }
        i++;
        String++;
    }

    String -= i;
    delete[] String;

    return Container;
}

vector<string> StringSplit::split_string(char Delimiter)
{
    do_string = true;

    int i = 0;
    while (*String)
    {
        if (*String != Delimiter && i == 0)
        {
            assimilate(String, Delimiter);
        }
        if (*String == Delimiter)
        {
            assimilate(String, Delimiter);
        }
        i++;
        String++;
    }

    String -= i;
    delete[] String;

    return ContainerS;
}

vector<char*> StringSplit::split_cstr(char* Delimiter)
{
    int i = 0;
    size_t LenDelim = calc_string_size(Delimiter);

    while(*String)
    {
        if (!match_fragment(String, Delimiter, LenDelim) && i == 0)
        {
            assimilate(String, Delimiter);
        }
        if (match_fragment(String, Delimiter, LenDelim))
        {
            assimilate(String,Delimiter);
        }
        i++;
        String++;
    }

    String -= i;
    delete[] String;

    return Container;
}

vector<string> StringSplit::split_string(char* Delimiter)
{
    do_string = true;
    int i = 0;
    size_t LenDelim = calc_string_size(Delimiter);

    while (*String)
    {
        if (!match_fragment(String, Delimiter, LenDelim) && i == 0)
        {
            assimilate(String, Delimiter);
        }
        if (match_fragment(String, Delimiter, LenDelim))
        {
            assimilate(String, Delimiter);
        }
        i++;
        String++;
    }

    String -= i;
    delete[] String;

    return ContainerS;
}

Örnekler:

int main(int argc, char*argv[])
{
    StringSplit ss = "This:CUT:is:CUT:an:CUT:example:CUT:cstring";
    vector<char*> Split = ss.split_cstr(":CUT:");

    for (int i = 0; i < Split.size(); i++)
    {
        cout << Split[i] << endl;
    }

    return 0;
}

Çıktı olacak:

Bu
ise
, bir
örnek,
CString

int main(int argc, char*argv[])
{
    StringSplit ss = "This:is:an:example:cstring";
    vector<char*> Split = ss.split_cstr(':');

    for (int i = 0; i < Split.size(); i++)
    {
        cout << Split[i] << endl;
    }

    return 0;
}

int main(int argc, char*argv[])
{
    string mystring = "This[SPLIT]is[SPLIT]an[SPLIT]example[SPLIT]string";
    StringSplit ss = mystring;
    vector<string> Split = ss.split_string("[SPLIT]");

    for (int i = 0; i < Split.size(); i++)
    {
        cout << Split[i] << endl;
    }

    return 0;
}

int main(int argc, char*argv[])
{
    string mystring = "This|is|an|example|string";
    StringSplit ss = mystring;
    vector<string> Split = ss.split_string('|');

    for (int i = 0; i < Split.size(); i++)
    {
        cout << Split[i] << endl;
    }

    return 0;
}

Boş girişleri tutmak için (varsayılan olarak boşluklar hariç tutulacaktır):

StringSplit ss = mystring;
ss.keep_empty = true;
vector<string> Split = ss.split_string(":DELIM:");

Amaç, dizeyi bölmenin şu kadar kolay olduğu C # 'ın Split () yöntemine benzer hale getirmekti:

String[] Split = 
    "Hey:cut:what's:cut:your:cut:name?".Split(new[]{":cut:"}, StringSplitOptions.None);

foreach(String X in Split)
{
    Console.Write(X);
}

Umarım başka biri bunu benim kadar faydalı bulabilir.

Peki buna ne dersin:

#include <string>
#include <vector>

using namespace std;

vector<string> split(string str, const char delim) {
    vector<string> v;
    string tmp;

    for(string::const_iterator i; i = str.begin(); i <= str.end(); ++i) {
        if(*i != delim && i != str.end()) {
            tmp += *i; 
        } else {
            v.push_back(tmp);
            tmp = ""; 
        }   
    }   

    return v;
}

Bu cevap dizeyi alır ve dizelerin bir vektörüne koyar. Destek kütüphanesini kullanır.

#include <boost/algorithm/string.hpp>
std::vector<std::string> strs;
boost::split(strs, "string to split", boost::is_any_of("\t "));

İşte bunu yapmanın başka bir yolu ..

void split_string(string text,vector<string>& words)
{
  int i=0;
  char ch;
  string word;

  while(ch=text[i++])
  {
    if (isspace(ch))
    {
      if (!word.empty())
      {
        words.push_back(word);
      }
      word = "";
    }
    else
    {
      word += ch;
    }
  }
  if (!word.empty())
  {
    words.push_back(word);
  }
}

Bölme ölçütlerini belirlemek için maksimum esneklik sağladıkları için bu görev için boost / regex yöntemlerini kullanmayı seviyorum.

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

int main() {
    std::string line("A:::line::to:split");
    const boost::regex re(":+"); // one or more colons

    // -1 means find inverse matches aka split
    boost::sregex_token_iterator tokens(line.begin(),line.end(),re,-1);
    boost::sregex_token_iterator end;

    for (; tokens != end; ++tokens)
        std::cout << *tokens << std::endl;
}

Son zamanlarda deve kasalı bir kelimeyi alt kelimelere bölmek zorunda kaldım. Sınırlayıcı yok, sadece üst karakterler var.

#include <string>
#include <list>
#include <locale> // std::isupper

template<class String>
const std::list<String> split_camel_case_string(const String &s)
{
    std::list<String> R;
    String w;

    for (String::const_iterator i = s.begin(); i < s.end(); ++i) {  {
        if (std::isupper(*i)) {
            if (w.length()) {
                R.push_back(w);
                w.clear();
            }
        }
        w += *i;
    }

    if (w.length())
        R.push_back(w);
    return R;
}

Örneğin, bu "AQueryTrades" i "A", "Query" ve "Trades" e böler. İşlev dar ve geniş tellerle çalışır. Mevcut yerel ayara saygı duyduğu için "RaumfahrtÜberwachungsVerordnung" u "Raumfahrt", "Überwachungs" ve "Verordnung" a böler.

Not std::uppergerçekten işlev şablonu argümanı olarak iletilmelidir. Daha sonra bu fonksiyondan daha genelleştirilmiş olan ",", ";"veya gibi sınırlayıcılara bölünebilir " ".

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

    vector<string> split(const string &s, char delim) {
        vector<string> elems;
        stringstream ss(s);
        string item;
        while (getline(ss, item, delim)) {
            elems.push_back(item);
        }
        return elems;
    }

int main() {

        vector<string> x = split("thi is an sample test",' ');
        unsigned int i;
        for(i=0;i<x.size();i++)
            cout<<i<<":"<<x[i]<<endl;
        return 0;
}

Kullanılması std::string_viewve Eric Niebler en range-v3kütüphanesi:

https://wandbox.org/permlink/kW5lwRCL1pxjp2pW

#include <iostream>
#include <string>
#include <string_view>
#include "range/v3/view.hpp"
#include "range/v3/algorithm.hpp"

int main() {
    std::string s = "Somewhere down the range v3 library";
    ranges::for_each(s  
        |   ranges::view::split(' ')
        |   ranges::view::transform([](auto &&sub) {
                return std::string_view(&*sub.begin(), ranges::distance(sub));
            }),
        [](auto s) {std::cout << "Substring: " << s << "\n";}
    );
}

Algoritma foryerine bir aralık döngüsü kullanarak ranges::for_each:

#include <iostream>
#include <string>
#include <string_view>
#include "range/v3/view.hpp"

int main()
{
    std::string str = "Somewhere down the range v3 library";
    for (auto s : str | ranges::view::split(' ')
                      | ranges::view::transform([](auto&& sub) { return std::string_view(&*sub.begin(), ranges::distance(sub)); }
                      ))
    {
        std::cout << "Substring: " << s << "\n";
    }
}