// splits a std::string into vector<string> at a delimiter

vector<string> split(string x, char delim = ' ')

{

    x += delim; //includes a delimiter at the end so last word is also read

    vector<string> splitted;

    string temp = "";

    for (int i = 0; i < x.length(); i++)

    {

        if (x[i] == delim)

        {

            splitted.push_back(temp); //store words in "splitted" vector

            temp = "";

            i++;

        }

        temp += x[i];

    }

    return splitted;

}

#include <iostream>

#include <sstream>

#include <vector>

​

using namespace std;

​

// for string delimiter

vector<string> split (string s, string delimiter) {

    size_t pos_start = 0, pos_end, delim_len = delimiter.length();

    string token;

    vector<string> res;

​

    while ((pos_end = s.find (delimiter, pos_start)) != string::npos) {

        token = s.substr (pos_start, pos_end - pos_start);

        pos_start = pos_end + delim_len;

        res.push_back (token);

    }

​

    res.push_back (s.substr (pos_start));

    return res;

}

​

int main() {

    string str = "adsf-+qwret-+nvfkbdsj-+orthdfjgh-+dfjrleih";

    string delimiter = "-+";

    vector<string> v = split (str, delimiter);

​

    for (auto i : v) cout << i << endl;

​

    return 0;

}

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

    std::stringstream ss(s);

    std::string item;

    while(std::getline(ss, item, delim)) {

        elems.push_back(item);

    }

    return elems;

}

​

#include<iostream>

#include<bits/stdc++.h>

using namespace std;

​

vector<string> string_burst(string str,char delimeter) 

{

  //condition: works with only single character delimeter, like $,_,space,etc.

    vector<string> words;

    int n=str.length();

    for(int i=0;i<n;i++)

    {

        int j=i;

        while(str[i]!=delimeter && i<n)

           i++;

        string temp=str.substr(j,i-j);

        words.push_back(temp);

    }

    return words;

}

std::vector<std::string> split(std::string str, char delim = ' ') {

  std::vector<std::string> result;

  size_t start = 0;

  while (start < str.length()) {

    size_t pos = str.find(delim, start);

    if (pos == std::string::npos) pos = str.length();

    result.push_back(str.substr(start, pos - start));

    start = pos + 1;

  }

  return result;

}

std::vector<std::string> split_string(const std::string& str,

                                      const std::string& delimiter)

{

    std::vector<std::string> strings;

​

    std::string::size_type pos = 0;

    std::string::size_type prev = 0;

    while ((pos = str.find(delimiter, prev)) != std::string::npos)

    {

        strings.push_back(str.substr(prev, pos - prev));

        prev = pos + 1;

    }

​

    // To get the last substring (or only, if delimiter is not found)

    strings.push_back(str.substr(prev));

​

    return strings;

}

​

#include <iostream>

#include <vector>

#include <algorithm>

#include <string>

using namespace std;

​

vector<string> split(string d, char s) {

    vector<char> pos{};

    vector<string> tos{};

    string cutter = "";

    char separator = s;

    for (auto c : d) {

        if (c == separator) {

            tos.push_back(cutter);

            cutter = "";

​

        }

        else { cutter += c; }

    }

    return tos;

​

}

​

int main()

{

    string b = "My name is voosh "; // add a separator at the end of the line

    char n = ' ';

   vector<string> col = split(b, n);

   for (auto p : col) {

       cout << p<<endl;

   }

}

​

#include <boost/algorithm/string.hpp>

​

std::string text = "Let me split this into words";

std::vector<std::string> results;

​

boost::split(results, text, [](char c){return c == ' ';});

std::vector<std::string> split(const std::string& str, char delimiter) {

    std::stringstream ss(str);

    std::vector<std::string> result;

    std::string segment;

    while(std::getline(ss, segment, delimiter)) {

        result.push_back(segment);

    }

    return result;

}

void simple_tokenizer(string s)

{

    stringstream ss(s);

    string word;

    while (ss >> word) {

        cout << word << endl;

    }

}