Bir dize kelimelerini nas─▒l yineleyebilirim?


Al─▒nan cevaba git


Bir dize s├Âzlerini yinelemeye ├žal─▒┼č─▒yorum.

Dize, bo┼člukla ayr─▒lm─▒┼č s├Âzc├╝klerden olu┼čtu─ču varsay─▒labilir.

C string fonksiyonlar─▒ veya bu t├╝r karakter manip├╝lasyonu / eri┼čimi ile ilgilenmedi─čimi unutmay─▒n. Ayr─▒ca, cevab─▒n─▒zdaki verim ├╝zerinde zarafete ├Âncelik verin.

┼×u an 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─▒?


2880









Cevap say─▒s─▒n─▒ say: 30






Ne pahas─▒na olursa olsun, sadece standart k├╝t├╝phane olanaklar─▒na dayanarak, bir giri┼č dizgisinden belirte├žleri ├ž─▒karman─▒n ba┼čka bir yolu. STL'nin tasar─▒m─▒n─▒n ard─▒ndaki g├╝├ž ve zarafetin bir ├Ârne─či.

 #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 ├ž─▒kt─▒ ak─▒┼č─▒na kopyalamak yerine, ayn─▒ jenerik copy algoritmay─▒ kullanarak bir kab─▒n i├žine yerle┼čtirmek m├╝mk├╝nd├╝r .

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

... veya vector do─črudan olu┼čturun :

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

1313







Bunu dizgeyi s─▒n─▒rlay─▒c─▒ya b├Âlmek i├žin kullan─▒yorum. 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 bulacaks─▒n─▒z:

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

2392







Y├╝kseltme kullanarak olas─▒ bir ├ž├Âz├╝m 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, stringstream yakla┼č─▒mdan daha h─▒zl─▒ olabilir . Ve bu genel bir ┼čablon i┼člevi oldu─čundan, her t├╝rl├╝ s─▒n─▒rlay─▒c─▒y─▒ kullanarak di─čer dizgileri (wchar, vb. Veya UTF-8) ay─▒rmak i├žin kullan─▒labilir.

Ayr─▒nt─▒lar i├žin belgelere bak─▒n.


825







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

352







Kod boyutu i├žin t├╝m verimlili─či feda etmenin ve "verimli" bir zarafet t├╝r├╝ olarak g├Ârmenin iyi bir ┼čekilde oturmamas─▒ gerekenler i├žin, a┼ča─č─▒dakiler tatl─▒ bir noktaya gelmelidir (ve ┼čablon kab─▒ s─▒n─▒f─▒n─▒n olduk├ža zarif bir eklenti 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 subString inan─▒lmaz h─▒z i├žin herhangi bir kopyas─▒n─▒ yapmaz art─▒┼člar.

Bu sayfadaki en h─▒zl─▒ g├Âstergenin iki kat─▒ndan daha h─▒zl─▒ ve di─čerlerinden 5 kat daha h─▒zl─▒. Ayr─▒ca m├╝kemmel parametre tipleri ile ek h─▒z art─▒┼člar─▒ i├žin t├╝m string ve liste kopyalar─▒n─▒ elimine edebilirsiniz.

Ek olarak, sonu├žta (son derece verimsiz) sonu├ž iadesi yap─▒lmaz, bunun yerine belirte├žleri bir referans olarak ge├žirir, b├Âylece diledi─činiz takdirde birden fazla ├ža─čr─▒ kullanarak belirte├žler olu┼čturman─▒za da izin verir.

Son olarak, son iste─če ba─čl─▒ bir parametre ile sonu├žlardan bo┼č belirte├žlerin k─▒rp─▒l─▒p k─▒rp─▒lmayaca─č─▒n─▒ belirlemenizi sa─člar.

─░htiyac─▒ olan tek ┼čey 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.


179







─░┼čte ba┼čka bir ├ž├Âz├╝m. Kompakt ve makul derecede 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;
}
 

Tel ay─▒r─▒c─▒lar─▒, geni┼č telleri vb. ─░┼člemek i├žin kolayca ┼čablonlanabilir.

B├Âlmenin "" tek bir bo┼č dizeyle sonu├žland─▒─č─▒n─▒ ve b├Âlmenin "," (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┼č belirte├žleri atlarken bir dizgiyi birden fazla s─▒n─▒rlay─▒c─▒ya b├Âlmek istenirse, 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;
}
 

158







Bu bir ipte yinelenmenin en sevdi─čim yolu. Her kelime i├žin 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...
}
 

118







Bu, Y─▒─č─▒n Ta┼čmas─▒ sorusuna benzer . C ++ 'da bir dizgiyi nas─▒l belirleyebilirim? .

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

80







A┼ča─č─▒dakileri severim ├ž├╝nk├╝ sonu├žlar─▒ bir vekt├Âre koyar, dizgiyi s─▒n─▒rlay─▒c─▒ olarak destekler ve bo┼č de─čerleri tutmak ├╝zerinde kontrol sa─člar. Ancak, o zaman kadar 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"));
}
 

Tabii ki, Boost split() k─▒smen b├Âyle ├žal─▒┼čan bir ┼čeye sahiptir. Ve e─čer "bo┼čluk" ile, ger├žekten Boost'un is_any_of() harika eserleri ile ayr─▒lmas─▒n─▒ kullanarak herhangi bir beyaz bo┼čluk demek istiyorsun .


67







STL'nin zaten b├Âyle bir y├Ântemi yok.

Bununla birlikte, ├╝yeyi kullanarak C'nin strtok() fonksiyonunu kullanabilir std::string::c_str() veya kendinizinkini yazabilirsiniz. ─░┼čte 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─▒nan: 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 a├ž─▒klayaca─č─▒m.

Ve sadece typedef denilen bir yineleyici ya da a┼č─▒r─▒ y├╝klenmedi─činden, << operat├Âr hatal─▒ kod oldu─ču anlam─▒na gelmez. C i┼člevlerini olduk├ža s─▒k kullan─▒yorum. ├ľrne─čin printf ve scanf her ikisi de daha h─▒zl─▒ std::cin ve std::cout (├Ânemli ├Âl├ž├╝de), fopen s├Âzdizimi ikili t├╝rler i├žin ├žok daha kolayd─▒r ve ayr─▒ca daha k├╝├ž├╝k EXE'ler ├╝retme e─čilimindedirler.

Bu "Performans ├ťzerindeki Elegance" anla┼čmas─▒nda sat─▒lmay─▒n .


53







─░┼čte ki bir fonksiyon:

  • genel
  • standart C ++ kullan─▒r (destek yok)
  • birden fazla s─▒n─▒rlay─▒c─▒y─▒ kabul eder
  • bo┼č belirte├žleri yoksayar (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";,");
 

43







Bu soruna 2 sat─▒rl─▒k bir ├ž├Âz├╝m├╝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;
 

Sonra bask─▒ yerine bir vekt├Âre koyabilirsiniz.


36







Bir ba┼čka 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;
  }
}
 

Bunu bir dizi vekt├Ârle kullanmak i├žin (D├╝zenleme: Biri STL s─▒n─▒flar─▒n─▒ miras almamay─▒ i┼čaret etti─činden beri ... 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! Ve bu, kelimelerin nas─▒l say─▒laca─č─▒ gibi, belirte├ž kullanman─▒n sadece bir yolu:

 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─▒;)


36







─░┼čte sadece standart regex k├╝t├╝phanesini 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;
}
 

Regex arg├╝man─▒, birden fazla arg├╝man (bo┼čluk, virg├╝l, vb.) Kontrol├╝ sa─člar.

Genelde sadece bo┼čluk ve virg├╝llere ay─▒rmay─▒ kontrol ederim, bu y├╝zden ┼ču varsay─▒lan fonksiyona da sahibim:

 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 ( , ).

Not b├Âlmek istiyorsan─▒z wstring yerine string ,

  • hepsini std::regex de─či┼čtir std::wregex
  • hepsini sregex_token_iterator de─či┼čtir wsregex_token_iterator

Ayr─▒ca, derleyicinize ba─čl─▒ olarak string arg├╝man─▒n─▒ referans olarak almak isteyebilirsiniz.


31







E─čer boost kullanmaktan ho┼član─▒yorsan─▒z, ancak b├╝t├╝n bir dizgiyi s─▒n─▒rlay─▒c─▒ olarak kullanmak istiyorsan─▒z (daha ├Ânce ├Ânerilen ├ž├Âz├╝mlerin ├žo─čunda oldu─ču gibi, tek karakterler yerine) kullanabilirsiniz 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;
}
 

26







Kullan─▒lmas─▒ std::stringstream E─čer m├╝kemmel ince i┼čleri varsa ve tam olarak ne istedi─čini yapt─▒─č─▒ gibi. Sadece farkl─▒ ┼čeyler yapman─▒n bir yolunu ar─▒yorsan─▒z, std::find() / std::find_first_of() ve 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;
}
 

26







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

20







Heres sadece standart regex k├╝t├╝phanesini kullanan bir regex ├ž├Âz├╝m├╝. (Biraz pasland─▒m, bu y├╝zden birka├ž s├Âzdizimi hatas─▒ olabilir, ama bu en az─▒ndan genel fikir)

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

19







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, ';')
 

17







┼×imdiye kadar olan─▒ Boost'ta kulland─▒m , ama buna ba─čl─▒ olmayan bir ┼čeye ihtiyac─▒m vard─▒, bu y├╝zden buna geldim:

 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 separators birden fazla karakter ge├žirmeniz olabilir.


14







Strtok kullanarak kendime yuvarlad─▒m ve bir ipi b├Âlmek i├žin destek kulland─▒m. Buldu─čum en iyi y├Ântem C ++ String Toolkit Library . ─░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├ž tak─▒m─▒, bu basit ├Ârnekten g├Âsterilenden daha fazla esnekli─če sahiptir, ancak bir dizgeyi yararl─▒ elemanlara ayr─▒┼čt─▒rmadaki faydas─▒ inan─▒lmazd─▒r.


13







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 de kullan─▒labilir (std :: string, null dahil ikili verileri destekler)

kullanarak:

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

├ž─▒kt─▒:

 this
is
!example!string
 

13







Bunu yapt─▒m ├ž├╝nk├╝ dizeleri ve c-tabanl─▒ dizeleri ay─▒rman─▒n kolay bir yoluna ihtiyac─▒m vard─▒ ... Umar─▒m bir ba┼čkas─▒ da onu yararl─▒ bulabilir. Ayr─▒ca belirte├žlere dayanmaz ve alanlar─▒ s─▒n─▒rlay─▒c─▒ olarak kullanabilirsiniz, bu da ihtiyac─▒m olan ba┼čka bir anahtar.

Zarafetini daha da iyile┼čtirmek i├žin geli┼čtirilebilecek geli┼čmeler oldu─čuna eminim ve l├╝tfen mutlaka 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;
}
 

Çıkacak:

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┼č b─▒rak─▒lacakt─▒r):

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

Ama├ž, C # 's Split () y├Ântemine benzer yapmakt─▒, burada bir dize b├Âlmek ┼ču kadar kolayd─▒:

 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 bunu ba┼čkas─▒ da benim kadar yararl─▒ bulabilir.


11







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

10







─░┼č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);
  }
}
 

9







B├Âlme ├Âl├ž├╝tlerini belirlemek i├žin maksimum esneklik sa─člad─▒klar─▒ndan, bu g├Ârev i├žin art─▒rma / 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;
}
 

9







Son zamanlarda deve harfli bir kelimeyi alt kelimelere b├Âlmek zorunda kald─▒m. S─▒n─▒rlay─▒c─▒ yok, sadece ├╝st karakter 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", "Sorgu" ve "─░┼člemler" ┼čeklinde b├Âler. Fonksiyon dar ve geni┼č karakter dizileriyle ├žal─▒┼č─▒r. Mevcut b├Âlgeye sayg─▒ duydu─ču i├žin "Raumfahrt├ťberwachungsVerordnung" ─▒ "Raumfahrt", "├ťberwachungs" ve "Verordnung" a b├Âlmektedir.

Not std::upper ger├žekten i┼člev ┼čablonu arg├╝man─▒ olarak iletilmelidir. O zaman bu fonksiyondan daha genel olan "," , ";" ya " " da gibi s─▒n─▒rlay─▒c─▒lara b├Âl├╝nebilir .


9







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

9







Bu cevap dizgiyi al─▒r ve dizgilerin bir vekt├Âr├╝ne koyar. Y├╝kseltme 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 "));
 

9







Takviye Al─▒n ! : -)

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

using namespace std;
using namespace boost;

int main(int argc, char**argv) {
    typedef vector < string > list_type;

    list_type list;
    string line;

    line = "Somewhere down the road";
    split(list, line, is_any_of(" "));

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

    return 0;
}
 

Bu ├Ârnek ├ž─▒kt─▒ verir -

 Somewhere
down
the
road
 

8