Btukfyl

I use this to split string by a delimiter. The first puts the results in a pre-constructed vector, the second returns a new vector.

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

}

Note that this solution does not skip empty tokens, so the following will find 4 items, one of which is empty:

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

A possible solution using Boost might be:

#include <boost/algorithm/string.hpp>

std::vector<std::string> strs;

boost::split(strs, "string to split", boost::is_any_of("t "));

This approach might be even faster than the stringstream approach. And since this is a generic template function it can be used to split other types of strings (wchar, etc. or UTF-8) using all kinds of delimiters.

See the documentation for details.

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

}

For those with whom it does not sit well to sacrifice all efficiency for code size and see "efficient" as a type of elegance, the following should hit a sweet spot (and I think the template container class is an awesomely elegant addition.):

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;

   }

}

I usually choose to use std::vector<std::string> types as my second parameter (ContainerT)... but list<> is way faster than vector<> for when direct access is not needed, and you can even create your own string class and use something like std::list<subString> where subString does not do any copies for incredible speed increases.

It's more than double as fast as the fastest tokenize on this page and almost 5 times faster than some others. Also with the perfect parameter types you can eliminate all string and list copies for additional speed increases.

Additionally it does not do the (extremely inefficient) return of result, but rather it passes the tokens as a reference, thus also allowing you to build up tokens using multiple calls if you so wished.

Lastly it allows you to specify whether to trim empty tokens from the results via a last optional parameter.

All it needs is std::string... the rest are optional. It does not use streams or the boost library, but is flexible enough to be able to accept some of these foreign types naturally.

Here's another solution. It's compact and reasonably efficient:

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;

}

It can easily be templatised to handle string separators, wide strings, etc.

Note that splitting "" results in a single empty string and splitting "," (ie. sep) results in two empty strings.

It can also be easily expanded to skip empty tokens:

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;

}

If splitting a string at multiple delimiters while skipping empty tokens is desired, this version may be used:

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;

}

This is my favorite way to iterate through a string. You can do whatever you want per word.

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

string word;



istringstream iss(line, istringstream::in);



while( iss >> word )     

{

    // Do something on `word` here...

}

This is similar to Stack Overflow question How do I tokenize a string in C++?.

#include <iostream>

#include <string>

#include <boost/tokenizer.hpp>



using namespace std;

using namespace boost;



int main(int argc, char** argv)

{

    string text = "token  testtstring";



    char_separator<char> sep(" t");

    tokenizer<char_separator<char>> tokens(text, sep);

    for (const string& t : tokens)

    {

        cout << t << "." << endl;

    }

}

I like the following because it puts the results into a vector, supports a string as a delim and gives control over keeping empty values. But, it doesn't look as good then.

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

}

Of course, Boost has a split() that works partially like that. And, if by 'white-space', you really do mean any type of white-space, using Boost's split with is_any_of() works great.

The STL does not have such a method available already.

However, you can either use C's strtok() function by using the std::string::c_str() member, or you can write your own. Here is a code sample I found after a quick Google search ("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);

    }

}

Taken from: http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html

If you have questions about the code sample, leave a comment and I will explain.

And just because it does not implement a typedef called iterator or overload the << operator does not mean it is bad code. I use C functions quite frequently. For example, printf and scanf both are faster than std::cin and std::cout (significantly), the fopen syntax is a lot more friendly for binary types, and they also tend to produce smaller EXEs.

Don't get sold on this "Elegance over performance" deal.

Here is a split function that:

• is generic


• uses standard C++ (no boost)


• accepts multiple delimiters


• 
  

  ignores empty tokens (can easily be changed)

  
  
  

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

  
  

Example usage:

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

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

I have a 2 lines solution to this problem:

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;

Then instead of printing you can put it in a vector.

Yet another flexible and fast way

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;

  }

}

To use it with a vector of strings (Edit: Since someone pointed out not to inherit STL classes... 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");

That's it! And that's just one way to use the tokenizer, like how to just
count words:

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

Limited by imagination ;)

Here's a simple solution that uses only the standard regex library

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

}

The regex argument allows checking for multiple arguments (spaces, commas, etc.)

I usually only check to split on spaces and commas, so I also have this default function:

std::vector<string> TokenizeDefault( const string str )

{

    using namespace std;



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



    return Tokenize( str, re );

}

The "[\s,]+" checks for spaces (\s) and commas (,).

Note, if you want to split wstring instead of string,

• change all std::regex to std::wregex
  


• change all sregex_token_iterator to wsregex_token_iterator
  

Note, you might also want to take the string argument by reference, depending on your compiler.

If you like to use boost, but want to use a whole string as delimiter (instead of single characters as in most of the previously proposed solutions), you can use the boost_split_iterator.

Example code including convenient template:

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

}

Using std::stringstream as you have works perfectly fine, and do exactly what you wanted. If you're just looking for different way of doing things though, you can use std::find()/std::find_first_of() and std::string::substr().

Here's an example:

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

}

There is a function named 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;

}

Heres a regex solution that only uses the standard regex library. (I'm a little rusty, so there may be a few syntax errors, but this is at least the general idea)

#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

}

The stringstream can be convenient if you need to parse the string by non-space symbols:

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

So far I used the one in Boost, but I needed something that doesn't depends on it, so I came to this:

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

}

A good point is that in separators you can pass more than one character.

I've rolled my own using strtok and used boost to split a string. The best method I have found is the C++ String Toolkit Library. It is incredibly flexible and fast.

#include <iostream>

#include <vector>

#include <string>

#include <strtk.hpp>



const char *whitespace  = " trnf";

const char *whitespace_and_punctuation  = " trnf;,=";



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;

}

The toolkit has much more flexibility than this simple example shows but its utility in parsing a string into useful elements is incredible.

Short and elegant

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

}

can use any string as delimiter, also can be used with binary data (std::string supports binary data, including nulls)

using:

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

output:

this

is

!example!string

I made this because I needed an easy way to split strings and c-based strings... Hopefully someone else can find it useful as well. Also it doesn't rely on tokens and you can use fields as delimiters, which is another key I needed.

I'm sure there's improvements that can be made to even further improve its elegance and please do by all means

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;

}

Examples:

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;

}

Will output:

This

is

an

example

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;

}

To keep empty entries (by default empties will be excluded):

StringSplit ss = mystring;

ss.keep_empty = true;

vector<string> Split = ss.split_string(":DELIM:");

The goal was to make it similar to C#'s Split() method where splitting a string is as easy as:

String Split = 

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



foreach(String X in Split)

{

    Console.Write(X);

}

I hope someone else can find this as useful as I do.

What about this:

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

}

Here's another way of doing it..

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

  }

}

I like to use the boost/regex methods for this task since they provide maximum flexibility for specifying the splitting criteria.

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

}

Recently I had to split a camel-cased word into subwords. There are no delimiters, just upper characters.

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

}

For example, this splits "AQueryTrades" into "A", "Query" and "Trades". The function works with narrow and wide strings. Because it respects the current locale it splits "RaumfahrtÜberwachungsVerordnung" into "Raumfahrt", "Überwachungs" and "Verordnung".

Note std::upper should be really passed as function template argument. Then the more generalized from of this function can split at delimiters like ",", ";" or " " too.

This answer takes the string and puts it into a vector of strings. It uses the boost library.

#include <boost/algorithm/string.hpp>

std::vector<std::string> strs;

boost::split(strs, "string to split", boost::is_any_of("t "));

Get Boost ! : -)

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

}

This example gives the output -

Somewhere

down

the

road

The code below uses strtok() to split a string into tokens and stores the tokens in a vector.

#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   = " ,tn";

char *token;







int main()

{

   vector<string> vec_String_Lines;

   token = strtok( one_line_string, seps );



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



   while( token != NULL )

   {

      vec_String_Lines.push_back(token);

      token = strtok( NULL, seps );

   }

     cout << "Displaying end result in vector line storage..nn";



    for ( int i = 0; i < vec_String_Lines.size(); ++i)

    cout << vec_String_Lines[i] << "n";

    cout << "nnn";





return 0;

}