programming - c++ tutorialspoint pdf




كيف يمكنني التكرار فوق كلمات سلسلة؟ (20)

أحاول التكرار فوق كلمات سلسلة.

يمكن افتراض أن السلسلة تتكون من كلمات مفصولة بمسافة بيضاء.

لاحظ أنني لست مهتمًا بوظائف سلسلة C أو ذلك النوع من التلاعب بالحرف / الوصول. أيضا ، يرجى إعطاء الأسبقية للأناقة على الكفاءة في إجابتك.

أفضل حل لدي الآن هو:

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

هل هناك طريقة أكثر أناقة للقيام بذلك؟


أنا أحب ما يلي لأنه يضع النتائج في متجه ، ويدعم سلسلة كدليل ويعطي السيطرة على الحفاظ على القيم الفارغة. ولكن ، لا تبدو جيدة بعد ذلك.

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

بالطبع ، لدى Boost split() يعمل بشكل جزئي مثل ذلك. وإذا كنت من خلال "المسافة البيضاء" ، فأنت تعني أي نوع من المسافات البيضاء ، باستخدام انقسام Boost مع is_any_of() يعمل بشكل رائع.


أنا استخدم هذا لتقسيم السلسلة من قبل محدد. يضع الأول النتائج في ناقل متجه مسبقًا ، ويعود الثاني إلى متجه جديد.

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

template<typename Out>
void split(const std::string &s, char delim, Out result) {
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, 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;
}

لاحظ أن هذا الحل لا يتخطى الرموز الفارغة ، لذلك سيجد ما يلي 4 عناصر ، واحد منها فارغ:

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

إليك حل بسيط يستخدم فقط مكتبة regex القياسية

#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 بالتحقق من الوسيطات المتعددة (المسافات ، الفواصل ، إلخ.)

عادةً ما أتحقق فقط من التقسيم على المساحات والفواصل ، لذلك لدي أيضًا هذه الوظيفة الافتراضية:

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

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

    return Tokenize( str, re );
}

يتحقق "[\\s,]+" وجود مسافات ( \\s ) وفواصل ( , ).

ملاحظة ، إذا كنت تريد تقسيم wstring بدلاً من string ،

  • تغيير جميع std::regex إلى std::wregex
  • تغيير كل sregex_token_iterator إلى wsregex_token_iterator

ملاحظة ، قد تحتاج أيضًا إلى استخدام الوسيطة string بالرجوع ، استنادًا إلى المترجم الخاص بك.


الحل المحتمل باستخدام Boost قد يكون:

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

قد يكون هذا النهج أسرع من نهج stringstream . وبما أن هذه هي وظيفة قالب عام ، يمكن استخدامها لتقسيم أنواع أخرى من السلاسل (wchar ، إلخ. أو UTF-8) باستخدام جميع أنواع المحددات.

انظر documentation لمزيد من التفاصيل.


بالنسبة لأولئك الذين لا يجلسون بشكل جيد للتضحية بكافة الكفاءة لحجم الرمز ورؤية "كفاءة" كنوع من الأناقة ، يجب أن تصل إلى نقطة حلوة (وأعتقد أن فئة حاوية القالب إضافة أنيقة بذهول):

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

اختر عادة استخدام أنواع std::vector<std::string> كمعاملتي الثانية ( ContainerT ) ... لكن list<> هي طريقة أسرع من vector<> عندما لا تكون هناك حاجة إلى الوصول المباشر ، ويمكنك حتى إنشاء فئة السلسلة الخاصة بك واستخدام شيء مثل std::list<subString> حيث لا تقوم subString بأي نسخ لزيادة السرعة بشكل لا يصدق.

إنها أكثر من ضعف سرعة أسرع الرموز على هذه الصفحة وما يقرب من 5 مرات أسرع من البعض الآخر. أيضًا مع أنواع المعلمات المثالية ، يمكنك إزالة جميع نسخ السلسلة والقائمة لزيادة السرعة الإضافية.

بالإضافة إلى ذلك ، فإنه لا يؤدي إلى نتيجة (غير فعالة للغاية) للنتيجة ، ولكنه يمرر الرموز المميزة كمرجع ، وبالتالي يسمح لك بتكوين الرموز باستخدام مكالمات متعددة إذا رغبت في ذلك.

وأخيرًا ، تسمح لك بتحديد ما إذا كنت تريد إزالة الرموز الفارغة من النتائج عبر معلمة اختيارية أخيرة.

كل ما يحتاجه هو std::string ... والباقي اختيارية. لا يستخدم تيارات أو مكتبة boost ، ولكنه مرن بالقدر الكافي ليتمكن من قبول بعض هذه الأنواع الخارجية بشكل طبيعي.


بعد طريقة أخرى مرنة وسريعة

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

لاستخدامها مع متجه السلاسل (تحرير: منذ أشار شخص ما إلى عدم ترث فصول STL ... 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");

هذا هو! وهذه مجرد طريقة واحدة لاستخدام أداة tokenizer ، مثل كيفية حساب الكلمات فقط:

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

مقيدة بالخيال ؛)


لا تملك المحكمة الخاصة بلبنان هذه الطريقة متاحة بالفعل.

ومع ذلك ، يمكنك استخدام الدالة strtok() C باستخدام العضو std::string::c_str() أو يمكنك كتابة الخاصة بك. في ما يلي نموذج تعليمة برمجية عثرت عليه بعد بحث Google سريع ( "تقسيم سلسلة STL" ):

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

مأخوذة من: http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html

إذا كانت لديك أسئلة حول نموذج التعليمات البرمجية ، فاترك تعليقًا وسأشرح لك.

ولأنه لا يقوم بتطبيق typedef يسمى iterator أو overload ، فإن المشغل << لا يعني أنه شفرة سيئة. أنا استخدم C وظائف في كثير من الأحيان. على سبيل المثال ، تكون كل من printf و scanf أسرع من std::cin و std::cout (بشكل ملحوظ) ، وبناء الجملة fopen هو أكثر ملاءمة للأنواع الثنائية ، كما أنها تميل إلى إنتاج EXE أصغر.

لا تباع في صفقة "أناقة على الأداء" هذه .


لدي حل خطوط 2 لهذه المشكلة:

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;

ثم بدلا من الطباعة يمكنك وضعها في ناقلات.


هذا مشابه لسؤال كيف أقوم بتكوين سلسلة في C ++؟ .

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

هذه هي الطريقة المفضلة للتكرار من خلال سلسلة. يمكنك أن تفعل ما تريد بكلمة.

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

istringstream iss(line, istringstream::in);

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

هناك وظيفة تسمى 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;
}

هيريس حل regex يستخدم فقط مكتبة regex القياسية. (أنا صدئ قليلاً ، لذلك قد يكون هناك بعض الأخطاء النحوية ، ولكن هذه هي الفكرة العامة على الأقل)

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

يمكن أن يكون stringstream مناسبًا إذا كنت بحاجة إلى تحليل السلسلة عن طريق الرموز غير الفضائية:

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

أرغب في استخدام أساليب boost / regex لهذه المهمة لأنها توفر أقصى قدر من المرونة لتحديد معايير التقسيم.

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

قصيرة وأنيقة

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

يمكن استخدام أي سلسلة كمحدد ، كما يمكن استخدامه مع البيانات الثنائية (يدعم std :: string البيانات الثنائية ، بما في ذلك القيم الخالية)

باستخدام:

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

انتاج:

this
is
!example!string

ماذا عن هذا:

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

تأخذ هذه الإجابة السلسلة وتضعها في متجه من السلاسل. ويستخدم مكتبة دفعة.

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

في الآونة الأخيرة ، كان علي أن أقوم بتقسيم كلمة الجمل إلى كلمات فرعية. لا توجد المحددات ، فقط الشخصيات العليا.

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

على سبيل المثال ، يؤدي هذا إلى تقسيم "AQueryTrades" إلى "A" و "Query" و "Trades". تعمل الدالة مع السلاسل الضيقة والواسعة. ولأنها تحترم الموقع الحالي ، فإنها تقسم "RaumfahrtÜberwachungsVerordnung" إلى "Raumfahrt" و "Überwachungs" و "Verordnung".

std::upperيجب أن يتم تمرير الملاحظة كوسيطة قالب الدالة. ثم يمكن تقسيم أكثر عمومية من هذه الوظيفة في المحددات ","، ";"أو " "أيضًا.


لقد صنعت هذا لأنني كنت في حاجة إلى طريقة سهلة لتقسيم السلاسل والأسلاك المستندة إلى c ... نأمل أن يجدها شخص آخر مفيدًا أيضًا. كما أنه لا يعتمد على الرموز ويمكنك استخدام الحقول كمحددات ، وهو مفتاح آخر أحتاج إليه.

أنا متأكد من أن هناك تحسينات يمكن إجراؤها لزيادة تحسين أناقتها والرجاء القيام بها بكل الوسائل

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

أمثلة:

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

سوف الناتج:

هذا
هو
على
سبيل المثال
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;
}

للحفاظ على إدخالات فارغة (سيتم استبعاد الفوارق الافتراضية):

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

كان الهدف هو جعله مشابهاً لأسلوب Split () الخاص بـ C # حيث يكون تقسيم السلسلة سهلاً كما يلي:

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

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

آمل أن يجد شخص آخر ذلك مفيدًا كما أفعل.


يستخدم الرمز أدناه strtok()لتقسيم سلسلة إلى رموز ويخزن الرموز المميزة في متجه.

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

using namespace std;


char one_line_string[] = "hello hi how are you nice weather we are having ok then bye";
char seps[]   = " ,\t\n";
char *token;



int main()
{
   vector<string> vec_String_Lines;
   token = strtok( one_line_string, seps );

   cout << "Extracting and storing data in a vector..\n\n\n";

   while( token != NULL )
   {
      vec_String_Lines.push_back(token);
      token = strtok( NULL, seps );
   }
     cout << "Displaying end result in vector line storage..\n\n";

    for ( int i = 0; i < vec_String_Lines.size(); ++i)
    cout << vec_String_Lines[i] << "\n";
    cout << "\n\n\n";


return 0;
}






split