文字列の単語をどのように反復するのですか？

Question

文字列の単語を反復しようとしています。

文字列は空白で区切られた単語で構成されていると見なすことができます。

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

もっとエレガントな方法はありますか？

Zunino · Accepted Answer

その価値があるので、これは入力文字列からトークンを抽出するもう一つの方法で、標準のライブラリ機能だけに頼ります。それはSTLのデザインの背後にある力と優雅さの一例です。

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

抽出されたトークンを出力ストリームにコピーする代わりに、同じ一般的なcopyアルゴリズムを使ってそれらをコンテナに挿入することができます。

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

...または直接vectorを作成します。

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

Evan Teran · Answer

これを使って文字列を区切り文字で分割します。最初のものは事前に構築されたベクトルに結果を置き、2番目のものは新しいベクトルを返します。

#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つの項目を見つけ、そのうちの1つは空です。

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

ididak · Answer

Boostを使用して考えられる解決策は、次のとおりです。

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

このアプローチはstringstreamアプローチよりもさらに速いかもしれません。これは一般的なテンプレート関数なので、他の種類の文字列（wcharなどまたはUTF-8）をあらゆる種類の区切り文字を使って分割するために使用できます。

詳細はドキュメントを参照してください。

kev · Answer

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

Marius · Answer

コードサイズのすべての効率を犠牲にして、優雅さのタイプとして「効率的」を見るのが苦手な人にとっては、以下がスイートスポットに当たるはずです（そしてテンプレートコンテナクラスは驚くほどエレガントな追加だと思います）：

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

私は通常、2番目のパラメーターとしてstd::vector<std::string>型を使用することを選択します（ContainerT）...しかし、list<>は、直接アクセスが不要な場合にvector<>よりもはるかに高速です。独自の文字列クラスを作成し、std::list<subString>のようなものを使用することもできます。ここで、subStringは、信じられないほどの速度向上のためにコピーを行いません。

このページでの最速トークン化の2倍以上の速さで、他のいくつかの5倍の速さです。また、完璧なパラメータタイプを使用すると、すべての文字列とリストのコピーを削除して、速度をさらに向上させることができます。

さらに、結果の（非常に非効率的な）戻りを行いませんが、トークンを参照として渡します。したがって、必要に応じて、複数の呼び出しを使用してトークンを構築することもできます。

最後に、最後のオプションのパラメーターを使用して、結果から空のトークンを削除するかどうかを指定できます。

必要なのはstd::string...のみで、残りはオプションです。ストリームやブーストライブラリは使用しませんが、これらの外部型の一部を自然に受け入れることができるほど柔軟です。

Alec Thomas · Answer

これは別の解決策です。それはコンパクトでかなり効率的です：

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

文字列の区切り文字やワイド文字列などを扱うために簡単にテンプレート化することができます。

""を分割すると1つの空の文字列になり、","を分割すると（つまりsep）2つの空の文字列になることに注意してください。

空のトークンをスキップするように簡単に拡張することもできます。

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

空のトークンをスキップしながら複数の区切り文字で文字列を分割することが望ましい場合は、このバージョンを使用できます。

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

gnomed · Answer

これは、文字列を反復処理するための私のお気に入りの方法です。あなたは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... }

Ferruccio · Answer

これは、Stack Overflow question 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	string"; char_separator<char> sep(" 	"); tokenizer<char_separator<char>> tokens(text, sep); for (const string& t : tokens) { cout << t << "." << endl; } }

Shadow2531 · Answer

結果がベクトルになり、文字列を区切り文字としてサポートし、空の値を保持することを制御できるので、次のようにします。しかし、それほど良くは見えません。

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

もちろん、Boostには split() という部分的な動作があります。そして、 'white-space'と言えば、Boostのis_any_of()とsplitを使うことは本当にうまくいくということです。

nlaq · Answer

STLにはそのような方法はまだありません。

ただし、 strtok() メンバーを使用してCの std::string::c_str() 関数を使用することも、独自に作成することもできます。これは、Googleですばやく検索した結果のコードサンプルです（ "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); } }

撮影場所： http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html

コードサンプルについて質問がある場合は、コメントを入力してください。説明します。

そして、それがiteratorと呼ばれるtypedefを実装していないという理由や<<演算子はそれが悪いコードであるという意味ではありません。私はC関数を頻繁に使っています。例えば、 printf と scanf は、どちらも std::cin と std::cout よりも高速です。 fopen 構文は、バイナリ型にとってはるかに使いやすいです。彼らはまた、より小さなEXEを生成する傾向があります。

"Elegance over performance" で売られてはいけません。

Marco M. · Answer

これが分割関数です。

一般的です
標準のC++を使用します（ブーストなし）
複数の区切り文字を受け入れます

空のトークンを無視します（簡単に変更できます）

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

使用例

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

rhomu · Answer

私はこの問題を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;

印刷する代わりに、それをベクトルに入れることができます。

Robert · Answer

さらに別の柔軟で迅速な方法

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

それでおしまい！そしてそれはトークナイザーを使うただ一つの方法です。ちょうど単語を数える方法のように：

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", " 	"); ASSERT( wc.noOfWords == 7 );

想像力によって制限されます。）

dk123 · Answer

これは標準の正規表現ライブラリだけを使う簡単な解決策です。

#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に変更

コンパイラによっては、文字列の引数を参照することもできます。

zerm · Answer

Boostを使用したいが（以前に提案された解決策の大部分のように単一の文字の代わりに）文字列全体を区切り文字として使用したい場合は、boost_split_iteratorを使用することができます。

便利なテンプレートを含むサンプルコード：

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

KTC · Answer

std::stringstreamをあなたが持っているものとして使うことは完全にうまくいき、そしてあなたが望んだとおりにやる。しかし、やり方を変えたいだけなら、 std::find() / std::find_first_of() と std::string::substr() を使うことができます。

これが例です：

#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 << '
'; prev_pos = ++pos; } std::string substring( s.substr(prev_pos, pos-prev_pos) ); // Last Word std::cout << substring << '
'; return 0; }

Pratik Deoghare · Answer

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

AJMansfield · Answer

これは標準の正規表現ライブラリだけを使う正規表現の解決策です。（私は少し錆びているので、構文エラーがいくつかあるかもしれませんが、これは少なくとも一般的な考えです）

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

lukmac · Answer

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

Goran · Answer

これまでは Boost の中のものを使っていましたが、それに依存しないものが必要だったので、私はこれに来ました：

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

良い点は、separatorsでは複数の文字を渡すことができるということです。

user1438233 · Answer

短くてエレガント

#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はnullを含むバイナリデータをサポートします）。

を使用して：

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

出力：

this is !example!string

DannyK · Answer

私はstrtokを使用して自分自身をロールバックし、文字列を分割するためにboostを使用しました。私が見つけた最良の方法は C++文字列ツールキットライブラリです。それは信じられないほど柔軟で速いです。

#include <iostream> #include <vector> #include <string> #include <strtk.hpp> const char *whitespace = " 	
\f"; const char *whitespace_and_punctuation = " 	
\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; }

このツールキットは、この単純な例が示すよりもはるかに高い柔軟性を持っていますが、文字列を有用な要素に解析するというその有用性は信じられないほどです。

Steve Dell · Answer

これは、文字列とCベースの文字列を分割する簡単な方法が必要だったためです。また、トークンに頼らず、フィールドを区切り文字として使用することもできます。これは私が必要としているもう1つのキーです。

その優雅さをさらに向上させるために改善ができると確信しています、そしてぜひしてください

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

出力します：

この
は
an
の例
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:");

目標は、文字列を分割するのが簡単なC＃のSplit（）メソッドに似たものにすることでした。

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

私は他の誰かが私と同じくらい便利にこれを見つけることができると思います。

gibbz · Answer

これはどうですか：

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

NL628 · Answer

この答えは文字列を受け取り、それを文字列のベクトルに入れます。それはブーストライブラリを使用しています。

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

Marty B · Answer

分割基準を指定するための最大限の柔軟性を提供するので、このタスクには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; }

user246110 · Answer

これを行う別の方法はこちらです。

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

san45 · Answer

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

Andreas Spindler · Answer

最近私はラクダケースのWordをサブワードに分割しなければなりませんでした。区切り文字はなく、大文字だけがあります。

#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は、実際には関数テンプレートの引数として渡されるべきです。それからこの関数のより一般化されたものは","、";"または" "のような区切り文字で分割することができます。

Software_Designer · Answer

以下のコードは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[] = " ,	
"; char *token; int main() { vector<string> vec_String_Lines; token = strtok( one_line_string, seps ); cout << "Extracting and storing data in a vector..


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

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


"; return 0; }

Aleksey Bykov · Answer

ゲットブースト！： - ）

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

この例は出力を与えます -

Somewhere down the road

Abe · Answer

Stringクラスを "special"（つまり、標準ではない）にしたので、この単純語を使用します。

void splitString(const String &s, const String &delim, std::vector<String> &result) { const int l = delim.length(); int f = 0; int i = s.indexOf(delim,f); while (i>=0) { String token( i-f > 0 ? s.substring(f,i-f) : ""); result.Push_back(token); f=i+l; i = s.indexOf(delim,f); } String token = s.substring(f); result.Push_back(token); }

solstice333 · Answer

#include <iostream> #include <regex> using namespace std; int main() { string s = "foo bar baz"; regex e("\s+"); regex_token_iterator<string::iterator> i(s.begin(), s.end(), e, -1); regex_token_iterator<string::iterator> end; while (i != end) cout << " [" << *i++ << "]"; }

IMO、これはpythonのre.split（）に最も近いものです。 regex_token_iteratorの詳細については、 cplusplus.com を参照してください。 -1（regex_token_iterator ctorの4番目の引数）は、一致を区切り文字として使用した、一致しないシーケンスのセクションです。

Kelly Elton · Answer

以下はこれを行うためのはるかに良い方法です。それは任意の文字を取ることができ、あなたが望むのでなければ行を分割しません。特別なライブラリは必要ありません（まあ、std以外に、だれが本当にそれを追加のライブラリと見なしているのでしょう）、ポインタ、参照もなく、静的です。単純な単純なC++です。

#pragma once #include <vector> #include <sstream> using namespace std; class Helpers { public: static vector<string> split(string s, char delim) { stringstream temp (stringstream::in | stringstream::out); vector<string> elems(0); if (s.size() == 0 || delim == 0) return elems; for(char c : s) { if(c == delim) { elems.Push_back(temp.str()); temp = stringstream(stringstream::in | stringstream::out); } else temp << c; } if (temp.str().size() > 0) elems.Push_back(temp.str()); return elems; } //Splits string s with a list of delimiters in delims (it's just a list, like if we wanted to //split at the following letters, a, b, c we would make delims="abc". static vector<string> split(string s, string delims) { stringstream temp (stringstream::in | stringstream::out); vector<string> elems(0); bool found; if(s.size() == 0 || delims.size() == 0) return elems; for(char c : s) { found = false; for(char d : delims) { if (c == d) { elems.Push_back(temp.str()); temp = stringstream(stringstream::in | stringstream::out); found = true; break; } } if(!found) temp << c; } if(temp.str().size() > 0) elems.Push_back(temp.str()); return elems; } };

Jehjoa · Answer

趣味人として、これは私の頭に浮かんだ最初の解決策です。私がここで似たような解決策をまだ見ていないのは、ちょっと興味がありますが、どうやってやったのか根本的に間違っているのでしょうか。

#include <iostream> #include <string> #include <vector> std::vector<std::string> split(const std::string &s, const std::string &delims) { std::vector<std::string> result; std::string::size_type pos = 0; while (std::string::npos != (pos = s.find_first_not_of(delims, pos))) { auto pos2 = s.find_first_of(delims, pos); result.emplace_back(s.substr(pos, std::string::npos == pos2 ? pos2 : pos2 - pos)); pos = pos2; } return result; } int main() { std::string text{"And then I said: \"I don't get it, why would you even do that!?\""}; std::string delims{" :;\".,?!"}; auto words = split(text, delims); std::cout << "
Sentence:
 " << text << "

Words:"; for (const auto &w : words) { std::cout << "
 " << w; } return 0; }

http://cpp.sh/7wmzy

Jim Huang · Answer

私は次のようなコードを書きました。区切り文字を指定することができます。これは文字列にすることができます。結果はJavaのString.splitに似ていますが、結果に空の文字列が含まれます。

たとえば、split（ "ABCPICKABCANYABCTWO：ABC"、 "ABC"）を呼び出すと、結果は次のようになります。

0 <len:0> 1 PICK <len:4> 2 ANY <len:3> 3 TWO: <len:4> 4 <len:0>

コード：

vector <string> split(const string& str, const string& delimiter = " ") { vector <string> tokens; string::size_type lastPos = 0; string::size_type pos = str.find(delimiter, lastPos); while (string::npos != pos) { // Found a token, add it to the vector. cout << str.substr(lastPos, pos - lastPos) << endl; tokens.Push_back(str.substr(lastPos, pos - lastPos)); lastPos = pos + delimiter.size(); pos = str.find(delimiter, lastPos); } tokens.Push_back(str.substr(lastPos, str.size() - lastPos)); return tokens; }

Dietmar K&#252;hl · Answer

空白文字をセパレータとして扱うとき、std::istream_iterator<T>を使うことの明白な答えはすでに与えられていて、たくさん投票しました。もちろん、要素は空白文字で区切られるのではなく、何らかの区切り文字で区切られることがあります。私は、空白の意味を単にセパレータと定義するように再定義してから従来のアプローチを使用するような答えを見つけることはしませんでした。

ストリームが空白を考慮する方法を変更する方法は、単に空白の意味を定義するstd::localeファセットを使用してストリームのstd::ctype<char> using（std::istream::imbue()）を変更することです（std::ctype<wchar_t>に対しても行うことができます）。 std::ctype<char>はテーブル駆動型ですが、std::ctype<wchar_t>は仮想関数によって駆動されます。

#include <iostream> #include <algorithm> #include <iterator> #include <sstream> #include <locale> struct whitespace_mask { std::ctype_base::mask mask_table[std::ctype<char>::table_size]; whitespace_mask(std::string const& spaces) { std::ctype_base::mask* table = this->mask_table; std::ctype_base::mask const* tab = std::use_facet<std::ctype<char>>(std::locale()).table(); for (std::size_t i(0); i != std::ctype<char>::table_size; ++i) { table[i] = tab[i] & ~std::ctype_base::space; } std::for_each(spaces.begin(), spaces.end(), [=](unsigned char c) { table[c] |= std::ctype_base::space; }); } }; class whitespace_facet : private whitespace_mask , public std::ctype<char> { public: whitespace_facet(std::string const& spaces) : whitespace_mask(spaces) , std::ctype<char>(this->mask_table) { } }; struct whitespace { std::string spaces; whitespace(std::string const& spaces): spaces(spaces) {} }; std::istream& operator>>(std::istream& in, whitespace const& ws) { std::locale loc(in.getloc(), new whitespace_facet(ws.spaces)); in.imbue(loc); return in; } // everything above would probably go into a utility library... int main() { std::istringstream in("a, b, c, d, e"); std::copy(std::istream_iterator<std::string>(in >> whitespace(", ")), std::istream_iterator<std::string>(), std::ostream_iterator<std::string>(std::cout, "
")); std::istringstream pipes("a b c| d |e e"); std::copy(std::istream_iterator<std::string>(pipes >> whitespace("|")), std::istream_iterator<std::string>(), std::ostream_iterator<std::string>(std::cout, "
")); }

コードの大部分は、 ソフトデリミタを提供する汎用ツールをパッケージ化するためのものです。 ：連続した複数のデリミタがマージされています。空のシーケンスを生成する方法はありません。ストリーム内で異なる区切り文字が必要な場合は、おそらく共有ストリームバッファを使用して異なる方法でセットアップされたストリームを使用します。

void f(std::istream& in) { std::istream pipes(in.rdbuf()); pipes >> whitespace("|"); std::istream comma(in.rdbuf()); comma >> whitespace(","); std::string s0, s1; if (pipes >> s0 >> std::ws // read up to first pipe and ignore sequence of pipes && comma >> s1 >> std::ws) { // read up to first comma and ignore commas // ... } }

Galik · Answer

これが C++ 11 と _ stl _ を使った私の解決策です。それは適度に効率的であるべきです：

#include <vector> #include <string> #include <cstring> #include <iostream> #include <algorithm> #include <functional> std::vector<std::string> split(const std::string& s) { std::vector<std::string> v; const auto end = s.end(); auto to = s.begin(); decltype(to) from; while((from = std::find_if(to, end, [](char c){ return !std::isspace(c); })) != end) { to = std::find_if(from, end, [](char c){ return std::isspace(c); }); v.emplace_back(from, to); } return v; } int main() { std::string s = "this is the string to split"; auto v = split(s); for(auto&& s: v) std::cout << s << '
'; }

出力：

this is the string to split

Jairo Abdiel Toribio Cisneros · Answer

これは私のバージョンですKevの源を取った：

#include <string> #include <vector> void split(vector<string> &result, string str, char delim ) { string tmp; string::iterator i; result.clear(); for(i = str.begin(); i <= str.end(); ++i) { if((const char)*i != delim && i != str.end()) { tmp += *i; } else { result.Push_back(tmp); tmp = ""; } } }

その後、関数を呼び出してそれで何かをします：

vector<string> hosts; split(hosts, "192.168.1.2,192.168.1.3", ','); for( size_t i = 0; i < hosts.size(); i++){ cout << "Connecting Host : " << hosts.at(i) << "..." << endl; }

Dmitry · Answer

私は以下のコードを使います。

namespace Core { typedef std::wstring String; void SplitString(const Core::String& input, const Core::String& splitter, std::list<Core::String>& output) { if (splitter.empty()) { throw std::invalid_argument(); // for example } std::list<Core::String> lines; Core::String::size_type offset = 0; for (;;) { Core::String::size_type splitterPos = input.find(splitter, offset); if (splitterPos != Core::String::npos) { lines.Push_back(input.substr(offset, splitterPos - offset)); offset = splitterPos + splitter.size(); } else { lines.Push_back(input.substr(offset)); break; } } lines.swap(output); } } // gtest: class SplitStringTest: public testing::Test { }; TEST_F(SplitStringTest, EmptyStringAndSplitter) { std::list<Core::String> result; ASSERT_ANY_THROW(Core::SplitString(Core::String(), Core::String(), result)); } TEST_F(SplitStringTest, NonEmptyStringAndEmptySplitter) { std::list<Core::String> result; ASSERT_ANY_THROW(Core::SplitString(L"xy", Core::String(), result)); } TEST_F(SplitStringTest, EmptyStringAndNonEmptySplitter) { std::list<Core::String> result; Core::SplitString(Core::String(), Core::String(L","), result); ASSERT_EQ(1, result.size()); ASSERT_EQ(Core::String(), *result.begin()); } TEST_F(SplitStringTest, OneCharSplitter) { std::list<Core::String> result; Core::SplitString(L"x,y", L",", result); ASSERT_EQ(2, result.size()); ASSERT_EQ(L"x", *result.begin()); ASSERT_EQ(L"y", *result.rbegin()); Core::SplitString(L",xy", L",", result); ASSERT_EQ(2, result.size()); ASSERT_EQ(Core::String(), *result.begin()); ASSERT_EQ(L"xy", *result.rbegin()); Core::SplitString(L"xy,", L",", result); ASSERT_EQ(2, result.size()); ASSERT_EQ(L"xy", *result.begin()); ASSERT_EQ(Core::String(), *result.rbegin()); } TEST_F(SplitStringTest, TwoCharsSplitter) { std::list<Core::String> result; Core::SplitString(L"x,.y,z", L",.", result); ASSERT_EQ(2, result.size()); ASSERT_EQ(L"x", *result.begin()); ASSERT_EQ(L"y,z", *result.rbegin()); Core::SplitString(L"x,,y,z", L",,", result); ASSERT_EQ(2, result.size()); ASSERT_EQ(L"x", *result.begin()); ASSERT_EQ(L"y,z", *result.rbegin()); } TEST_F(SplitStringTest, RecursiveSplitter) { std::list<Core::String> result; Core::SplitString(L",,,", L",,", result); ASSERT_EQ(2, result.size()); ASSERT_EQ(Core::String(), *result.begin()); ASSERT_EQ(L",", *result.rbegin()); Core::SplitString(L",.,.,", L",.,", result); ASSERT_EQ(2, result.size()); ASSERT_EQ(Core::String(), *result.begin()); ASSERT_EQ(L".,", *result.rbegin()); Core::SplitString(L"x,.,.,y", L",.,", result); ASSERT_EQ(2, result.size()); ASSERT_EQ(L"x", *result.begin()); ASSERT_EQ(L".,y", *result.rbegin()); Core::SplitString(L",.,,.,", L",.,", result); ASSERT_EQ(3, result.size()); ASSERT_EQ(Core::String(), *result.begin()); ASSERT_EQ(Core::String(), *(++result.begin())); ASSERT_EQ(Core::String(), *result.rbegin()); } TEST_F(SplitStringTest, NullTerminators) { std::list<Core::String> result; Core::SplitString(L"xy", Core::String(L"\0", 1), result); ASSERT_EQ(1, result.size()); ASSERT_EQ(L"xy", *result.begin()); Core::SplitString(Core::String(L"x\0y", 3), Core::String(L"\0", 1), result); ASSERT_EQ(2, result.size()); ASSERT_EQ(L"x", *result.begin()); ASSERT_EQ(L"y", *result.rbegin()); }

landen · Answer

基本クラスとしてvectorを使い、そのすべての演算子にフルアクセスを与えるクイックバージョン：

 // Split string into parts. class Split : public std::vector<std::string> { public: Split(const std::string& str, char* delimList) { size_t lastPos = 0; size_t pos = str.find_first_of(delimList); while (pos != std::string::npos) { if (pos != lastPos) Push_back(str.substr(lastPos, pos-lastPos)); lastPos = pos + 1; pos = str.find_first_of(delimList, lastPos); } if (lastPos < str.length()) Push_back(str.substr(lastPos, pos-lastPos)); } };

STLセットを生成するための例

std::set<std::string> words; Split split("Hello,World", ","); words.insert(split.begin(), split.end());

Kaz · Answer

Boostなし、文字列ストリームなし、std::stringおよびstd::listと連携する標準Cライブラリ：分析を容易にするCライブラリ関数、メモリ管理を容易にするC++データ型。

空白は、改行、タブ、スペースの任意の組み合わせと見なされます。空白文字のセットはwschars変数によって設定されます。

#include <string> #include <list> #include <iostream> #include <cstring> using namespace std; const char *wschars = "	
 "; list<string> split(const string &str) { const char *cstr = str.c_str(); list<string> out; while (*cstr) { // while remaining string not empty size_t toklen; cstr += strspn(cstr, wschars); // skip leading whitespace toklen = strcspn(cstr, wschars); // figure out token length if (toklen) // if we have a token, add to list out.Push_back(string(cstr, toklen)); cstr += toklen; // skip over token } // ran out of string; return list return out; } int main(int argc, char **argv) { list<string> li = split(argv[1]); for (list<string>::iterator i = li.begin(); i != li.end(); i++) cout << "{" << *i << "}" << endl; return 0; }

実行します。

$ ./split "" $ ./split "a" {a} $ ./split " a " {a} $ ./split " a b" {a} {b} $ ./split " a b c" {a} {b} {c} $ ./split " a b c d " {a} {b} {c} {d}

splitの末尾再帰バージョン（それ自体が2つの関数に分割されています）。リストへの文字列のプッシュを除いて、変数の破壊的な操作はすべてなくなりました。

void split_rec(const char *cstr, list<string> &li) { if (*cstr) { const size_t leadsp = strspn(cstr, wschars); const size_t toklen = strcspn(cstr + leadsp, wschars); if (toklen) li.Push_back(string(cstr + leadsp, toklen)); split_rec(cstr + leadsp + toklen, li); } } list<string> split(const string &str) { list<string> out; split_rec(str.c_str(), out); return out; }

Rom&#225;rio · Answer

はい、私は30の例すべてを調べました。

複数文字の区切り文字に対応するsplitのバージョンが見つかりませんでした。

#include <string> #include <vector> using namespace std; vector<string> split(const string &str, const string &delim) { const auto delim_pos = str.find(delim); if (delim_pos == string::npos) return {str}; vector<string> ret{str.substr(0, delim_pos)}; auto tail = split(str.substr(delim_pos + delim.size(), string::npos), delim); ret.insert(ret.end(), tail.begin(), tail.end()); return ret; }

おそらく最も効率的な実装ではありませんが、<string>と<vector>のみを使用した、非常に直接的な再帰的解決策です。

ああ、それはC++ 11で書かれていますが、このコードに関して特別なものは何もないので、あなたは簡単にそれをC++ 98に適応させることができます。

smac89 · Answer

LazyStringSplitter：

#include <string> #include <algorithm> #include <unordered_set> using namespace std; class LazyStringSplitter { string::const_iterator start, finish; unordered_set<char> chop; public: // Empty Constructor explicit LazyStringSplitter() {} explicit LazyStringSplitter (const string cstr, const string delims) : start(cstr.begin()) , finish(cstr.end()) , chop(delims.begin(), delims.end()) {} void operator () (const string cstr, const string delims) { chop.insert(delims.begin(), delims.end()); start = cstr.begin(); finish = cstr.end(); } bool empty() const { return (start >= finish); } string next() { // return empty string // if ran out of characters if (empty()) return string(""); auto runner = find_if(start, finish, [&](char c) { return chop.count(c) == 1; }); // construct next string string ret(start, runner); start = runner + 1; // Never return empty string // + tail recursion makes this method efficient return !ret.empty() ? ret : next(); } };

テストプログラム

#include <iostream> using namespace std; int main() { LazyStringSplitter splitter; // split at the characters ' ', '!', '.', ',' splitter("This, is a string. And here is another string! Let's test and see how well this does.", " !.,"); while (!splitter.empty()) cout << splitter.next() << endl; return 0; }

_ output _

This is a string And here is another string Let's test and see how well this does

これを改善するための次の計画はbeginとendメソッドを実装して以下のようなことができるようにすることです。

vector<string> split_string(splitter.begin(), splitter.end());

yunhasnawa · Answer

文字列の区切り文字で文字列を分割する際に代替手段が必要な人のために、おそらくあなたは私の次の解決策を試すことができます。

std::vector<size_t> str_pos(const std::string &search, const std::string &target) { std::vector<size_t> founds; if(!search.empty()) { size_t start_pos = 0; while (true) { size_t found_pos = target.find(search, start_pos); if(found_pos != std::string::npos) { size_t found = found_pos; founds.Push_back(found); start_pos = (found_pos + 1); } else { break; } } } return founds; } std::string str_sub_index(size_t begin_index, size_t end_index, const std::string &target) { std::string sub; size_t size = target.length(); const char* copy = target.c_str(); for(size_t i = begin_index; i <= end_index; i++) { if(i >= size) { break; } else { char c = copy[i]; sub += c; } } return sub; } std::vector<std::string> str_split(const std::string &delimiter, const std::string &target) { std::vector<std::string> splits; if(!delimiter.empty()) { std::vector<size_t> founds = str_pos(delimiter, target); size_t founds_size = founds.size(); if(founds_size > 0) { size_t search_len = delimiter.length(); size_t begin_index = 0; for(int i = 0; i <= founds_size; i++) { std::string sub; if(i != founds_size) { size_t pos = founds.at(i); sub = str_sub_index(begin_index, pos - 1, target); begin_index = (pos + search_len); } else { sub = str_sub_index(begin_index, (target.length() - 1), target); } splits.Push_back(sub); } } } return splits; }

これらのスニペットは3つの機能で構成されています。悪いニュースはstr_split関数を使うことです。あなたは他の2つの関数を必要とします。はい、それは巨大なコードの塊です。しかし、幸いなことに、これら2つの追加機能は独立して機能することができ、時には便利なこともあります。

このようにmain()ブロックで関数をテストしました：

int main() { std::string s = "Hello, world! We need to make the world a better place. Because your world is also my world, and our children's world."; std::vector<std::string> split = str_split("world", s); for(int i = 0; i < split.size(); i++) { std::cout << split[i] << std::endl; } }

そしてそれは作り出すでしょう：

Hello, ! We need to make the a better place. Because your is also my , and our children's .

私はそれが最も効率的なコードではないと思いますが、少なくともそれはうまくいきます。それが役に立てば幸い。

ManiP · Answer

私は以下を使います

void split(string in, vector<string>& parts, char separator) { string::iterator ts, curr; ts = curr = in.begin(); for(; curr <= in.end(); curr++ ) { if( (curr == in.end() || *curr == separator) && curr > ts ) parts.Push_back( string( ts, curr )); if( curr == in.end() ) break; if( *curr == separator ) ts = curr + 1; } }

PlasmaHH、空白でトークンを削除するための追加チェック（curr> ts）を含めるのを忘れていました。

pz64_ · Answer

これがこの問題に対する私の解決策です。

vector<string> get_tokens(string str) { vector<string> dt; stringstream ss; string tmp; ss << str; for (size_t i; !ss.eof(); ++i) { ss >> tmp; dt.Push_back(tmp); } return dt; }

この関数は文字列のベクトルを返します。

mchiasson · Answer

これが私のバージョンです

#include <vector> inline std::vector<std::string> Split(const std::string &str, const std::string &delim = " ") { std::vector<std::string> tokens; if (str.size() > 0) { if (delim.size() > 0) { std::string::size_type currPos = 0, prevPos = 0; while ((currPos = str.find(delim, prevPos)) != std::string::npos) { std::string item = str.substr(prevPos, currPos - prevPos); if (item.size() > 0) { tokens.Push_back(item); } prevPos = currPos + 1; } tokens.Push_back(str.substr(prevPos)); } else { tokens.Push_back(str); } } return tokens; }

これは複数文字の区切り文字で機能します。空のトークンが結果に入らないようにします。単一のヘッダーを使用します。区切り文字を指定しないと、文字列は単一のトークンとして返されます。文字列が空の場合も空の結果が返されます。 C++ 11を使ってコンパイルしている巨大なstd::vector copy EXCEPTのため、残念ながら非効率的です。 C++ 11では、このコードは速いはずです。

robcsi · Answer

文字列を任意の長さの区切り文字で区切る方法を模索していたので、既存のソリューションでは適していないため、最初から作成し始めました。

これが私の小さなアルゴリズムで、STLだけを使っています。

//use like this //std::vector<std::wstring> vec = Split<std::wstring> (L"Hello##world##!", L"##"); template <typename valueType> static std::vector <valueType> Split (valueType text, const valueType& delimiter) { std::vector <valueType> tokens; size_t pos = 0; valueType token; while ((pos = text.find(delimiter)) != valueType::npos) { token = text.substr(0, pos); tokens.Push_back (token); text.erase(0, pos + delimiter.length()); } tokens.Push_back (text); return tokens; }

私がテストした範囲であれば、任意の長さと形式の区切り文字と一緒に使用できます。文字列型またはwstring型でインスタンス化します。

すべてのアルゴリズムは、区切り文字を検索し、区切り文字までの文字列の一部を取得し、区切り文字を削除して、それが見つからなくなるまで再度検索します。

もちろん、区切り文字には任意の数の空白を使用できます。

助けになれば幸いです。

User · Answer

これは私が多くのことをするのを助ける私が書いた機能です。 WebSocketsのためのプロトコルを作るときそれは私を助けました。

using namespace std; #include <iostream> #include <vector> #include <sstream> #include <string> vector<string> split ( string input , string split_id ) { vector<string> result; int i = 0; bool add; string temp; stringstream ss; size_t found; string real; int r = 0; while ( i != input.length() ) { add = false; ss << input.at(i); temp = ss.str(); found = temp.find(split_id); if ( found != string::npos ) { add = true; real.append ( temp , 0 , found ); } else if ( r > 0 && ( i+1 ) == input.length() ) { add = true; real.append ( temp , 0 , found ); } if ( add ) { result.Push_back(real); ss.str(string()); ss.clear(); temp.clear(); real.clear(); r = 0; } i++; r++; } return result; } int main() { string s = "S,o,m,e,w,h,e,r,e, down the road 
 In a really big C++ house. 
 Lives a little old lady. 
 That no one ever knew. 
 She comes outside. 
 In the very hot Sun. 







 And throws C++ at us. 
 The End. FIN."; vector < string > Token; Token = split ( s , "," ); for ( int i = 0 ; i < Token.size(); i++) cout << Token.at(i) << endl; cout << endl << Token.size(); int a; cin >> a; return a; }

Tristan Brindle · Answer

これが私のエントリーです：

template <typename Container, typename InputIter, typename ForwardIter> Container split(InputIter first, InputIter last, ForwardIter s_first, ForwardIter s_last) { Container output; while (true) { auto pos = std::find_first_of(first, last, s_first, s_last); output.emplace_back(first, pos); if (pos == last) { break; } first = ++pos; } return output; } template <typename Output = std::vector<std::string>, typename Input = std::string, typename Delims = std::string> Output split(const Input& input, const Delims& delims = " ") { using std::cbegin; using std::cend; return split<Output>(cbegin(input), cend(input), cbegin(delims), cend(delims)); } auto vec = split("Mary had a little lamb");

最初の定義は、2組の反復子をとるSTLスタイルの汎用関数です。二つ目はあなたがbegin()sとend()sをあなた自身でしなければならないあなたを救うための便利な機能です。たとえばlistを使用したい場合は、出力コンテナタイプをテンプレートパラメータとして指定することもできます。

それをエレガントにしているのは（IMO）、他のほとんどの答えとは異なり、文字列に限定されず、STL互換のどのコンテナでも動作するということです。上記のコードを変更することなく、あなたは言うことができます：

using vec_of_vecs_t = std::vector<std::vector<int>>; std::vector<int> v{1, 2, 0, 3, 4, 5, 0, 7, 8, 0, 9}; auto r = split<vec_of_vecs_t>(v, std::initializer_list<int>{0, 2});

0または2が見つかるたびに、ベクトルvを別々のベクトルに分割します。

（少なくとも私のシステムでは、文字列を使えば、この実装はstrtok()とgetline()の両方のバージョンより速いという追加のボーナスもあります。）

AlwaysLearning · Answer

利便性のためだけに：

template<class V, typename T> bool in(const V &v, const T &el) { return std::find(v.begin(), v.end(), el) != v.end(); }

複数の区切り文字に基づく実際の分割

std::vector<std::string> split(const std::string &s, const std::vector<char> &delims) { std::vector<std::string> res; auto stuff = [&delims](char c) { return !in(delims, c); }; auto space = [&delims](char c) { return in(delims, c); }; auto first = std::find_if(s.begin(), s.end(), stuff); while (first != s.end()) { auto last = std::find_if(first, s.end(), space); res.Push_back(std::string(first, last)); first = std::find_if(last + 1, s.end(), stuff); } return res; }

使い方

int main() { std::string s = " aaa, bb cc "; for (auto el: split(s, {' ', ','})) std::cout << el << std::endl; return 0; }

tony gil · Answer

// adapted from a "regular" csv parse std::string stringIn = "my csv is 10233478 NOTseparated by commas"; std::vector<std::string> commaSeparated(1); int commaCounter = 0; for (int i=0; i<stringIn.size(); i++) { if (stringIn[i] == " ") { commaSeparated.Push_back(""); commaCounter++; } else { commaSeparated.at(commaCounter) += stringIn[i]; } }

最後に、文のすべての要素をスペースで区切った文字列のベクトルができます。標準ではないリソースだけがstd :: vectorです（ただし、std :: stringが含まれているので、許容できると考えました）。

空の文字列は個別の項目として保存されます。

LLLL · Answer

私はまだ誰もこの解決策を投稿していないと思います。区切り文字を直接使用する代わりに、基本的にboost :: split（）と同じことをします。つまり、charが区切り文字であればtrueを返し、そうでなければfalseを返す述語を渡すことができます。私はこれがプログラマーにより多くのコントロールを与えると思います、そして素晴らしいことはあなたが後押しを必要としないということです。

template <class Container, class String, class Predicate> void split(Container& output, const String& input, const Predicate& pred, bool trimEmpty = false) { auto it = begin(input); auto itLast = it; while (it = find_if(it, end(input), pred), it != end(input)) { if (not (trimEmpty and it == itLast)) { output.emplace_back(itLast, it); } ++it; itLast = it; } }

それからあなたはこのようにそれを使うことができます：

struct Delim { bool operator()(char c) { return not isalpha(c); } }; int main() { string s("#include<iostream>
" "int main() { std::cout << \"Hello world!\" << std::endl; }"); vector<string> v; split(v, s, Delim(), true); /* Which is also the same as */ split(v, s, [](char c) { return not isalpha(c); }, true); for (const auto& i : v) { cout << i << endl; } }

doicanhden · Answer

私のコードは：

#include <list> #include <string> template<class StringType = std::string, class ContainerType = std::list<StringType> > class DSplitString:public ContainerType { public: explicit DSplitString(const StringType& strString, char cChar, bool bSkipEmptyParts = true) { size_t iPos = 0; size_t iPos_char = 0; while(StringType::npos != (iPos_char = strString.find(cChar, iPos))) { StringType strTemp = strString.substr(iPos, iPos_char - iPos); if((bSkipEmptyParts && !strTemp.empty()) || (!bSkipEmptyParts)) Push_back(strTemp); iPos = iPos_char + 1; } } explicit DSplitString(const StringType& strString, const StringType& strSub, bool bSkipEmptyParts = true) { size_t iPos = 0; size_t iPos_char = 0; while(StringType::npos != (iPos_char = strString.find(strSub, iPos))) { StringType strTemp = strString.substr(iPos, iPos_char - iPos); if((bSkipEmptyParts && !strTemp.empty()) || (!bSkipEmptyParts)) Push_back(strTemp); iPos = iPos_char + strSub.length(); } } };

例：

#include <iostream> #include <string> int _tmain(int argc, _TCHAR* argv[]) { DSplitString<> aa("doicanhden1;doicanhden2;doicanhden3;", ';'); for each (std::string var in aa) { std::cout << var << std::endl; } std::cin.get(); return 0; }

Venkata Naidu M · Answer

私達はc ++でstrtokを使うことができます、

#include <iostream> #include <cstring> using namespace std; int main() { char str[]="Mickey M;12034;911416313;M;01a;9001;NULL;0;13;12;0;CPP,C;MSC,3D;FEND,BEND,SEC;"; char *pch = strtok (str,";,"); while (pch != NULL) { cout<<pch<<"
"; pch = strtok (NULL, ";,"); } return 0; }

torayeff · Answer

#include <iostream> #include <vector> using namespace std; int main() { string str = "ABC AABCD CDDD RABC GHTTYU FR"; str += " "; //dirty hack: adding extra space to the end vector<string> v; for (int i=0; i<(int)str.size(); i++) { int a, b; a = i; for (int j=i; j<(int)str.size(); j++) { if (str[j] == ' ') { b = j; i = j; break; } } v.Push_back(str.substr(a, b-a)); } for (int i=0; i<v.size(); i++) { cout<<v[i].size()<<" "<<v[i]<<endl; } return 0; }

lemic · Answer

トークンとして ''を使用してgetlineをループします。

Saksham Sharma · Answer

これが私の考えです。入力文字列をWordごとに処理する必要がありました。これは、スペースを使用して単語を数えることで可能でしたが、それは面倒であり、単語をベクトルに分割する必要があると思いました。

#include<iostream> #include<vector> #include<string> #include<stdio.h> using namespace std; int main() { char x = '\0'; string s = ""; vector<string> q; x = getchar(); while(x != '
') { if(x == ' ') { q.Push_back(s); s = ""; x = getchar(); continue; } s = s + x; x = getchar(); } q.Push_back(s); for(int i = 0; i<q.size(); i++) cout<<q[i]<<" "; return 0; }

複数のスペースを考慮しません。
最後のWordの直後に改行文字が続かない場合は、最後のWordの最後の文字と改行文字の間に空白が含まれます。

user2588062 · Answer

私はちょうど文字ごとにcharを分割する方法の良い例を書いたところです。それは次に文字のそれぞれの配列（あなたのシンボルで区切られた単語）をベクトルに配置します。簡単にするために、私はstd文字列のベクトル型を作りました。

これが助けになり、読めることを願っています。

#include <vector> #include <string> #include <iostream> void Push(std::vector<std::string> &WORDS, std::string &TMP){ WORDS.Push_back(TMP); TMP = ""; } std::vector<std::string> mySplit(char STRING[]){ std::vector<std::string> words; std::string s; for(unsigned short i = 0; i < strlen(STRING); i++){ if(STRING[i] != ' '){ s += STRING[i]; }else{ Push(words, s); } } Push(words, s);//Used to get last split return words; } int main(){ char string[] = "My awesome string."; std::cout << mySplit(string)[2]; std::cin.get(); return 0; }

Timmmm · Answer

Galikの答えに基づいて私はこれを作りました。これはほとんどここにあるので私はそれを何度も何度も書き続ける必要はない。 C++にネイティブの分割関数がまだないのはおかしいです。特徴：

非常に速いはずです。
わかりやすい（と思います）。
空のセクションをマージします。
いくつかの区切り文字を使うのは簡単です（例：" "）

#include <string> #include <vector> #include <algorithm> std::vector<std::string> split(const std::string& s, const std::string& delims) { using namespace std; vector<string> v; // Start of an element. size_t elemStart = 0; // We start searching from the end of the previous element, which // initially is the start of the string. size_t elemEnd = 0; // Find the first non-delim, i.e. the start of an element, after the end of the previous element. while((elemStart = s.find_first_not_of(delims, elemEnd)) != string::npos) { // Find the first delem, i.e. the end of the element (or if this fails it is the end of the string). elemEnd = s.find_first_of(delims, elemStart); // Add it. v.emplace_back(s, elemStart, elemEnd == string::npos ? string::npos : elemEnd - elemStart); } // When there are no more non-spaces, we are done. return v; }

Porsche9II · Answer

std::string_viewとEric Nieblerのrange-v3ライブラリを使う：

https://wandbox.org/permlink/kW5lwRCL1pxjp2pW

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

okovko · Answer

私は他のソリューションにはさまざまな欠けているという点で多くの価値を提供する他のソリューションとは非常に異なるアプローチを持っていますが、もちろんそれ自身の欠点もあります。ここでは実用的な実装で、単語の周囲に<tag></tag>を配置する例です。

まず最初に、この問題は1つのループで追加のメモリを使わずに、4つの論理的なケースを考慮することで解決できます。概念的には、境界に関心があります。私たちのコードはそれを反映するべきです：文字列の始めと終わりに特別な場合があることを念頭に置いて、文字列を繰り返し調べて一度に2文字を見てみましょう。

欠点は、実装を記述する必要があることです。これはやや冗長ですが、ほとんど便利な定型句です。

利点は、実装を書いたことです。したがって、左右のWordの境界の区別、一連の区切り記号の使用、境界以外や誤った位置などの他のケースの処理など、特定のニーズに合わせてカスタマイズするのは非常に簡単です。

using namespace std; #include <iostream> #include <string> #include <cctype> typedef enum boundary_type_e { E_BOUNDARY_TYPE_ERROR = -1, E_BOUNDARY_TYPE_NONE, E_BOUNDARY_TYPE_LEFT, E_BOUNDARY_TYPE_RIGHT, } boundary_type_t; typedef struct boundary_s { boundary_type_t type; int pos; } boundary_t; bool is_delim_char(int c) { return isspace(c); // also compare against any other chars you want to use as delimiters } bool is_Word_char(int c) { return ' ' <= c && c <= '~' && !is_delim_char(c); } boundary_t maybe_Word_boundary(string str, int pos) { int len = str.length(); if (pos < 0 || pos >= len) { return (boundary_t){.type = E_BOUNDARY_TYPE_ERROR}; } else { if (pos == 0 && is_Word_char(str[pos])) { // if the first character is Word-y, we have a left boundary at the beginning return (boundary_t){.type = E_BOUNDARY_TYPE_LEFT, .pos = pos}; } else if (pos == len - 1 && is_Word_char(str[pos])) { // if the last character is Word-y, we have a right boundary left of the null terminator return (boundary_t){.type = E_BOUNDARY_TYPE_RIGHT, .pos = pos + 1}; } else if (!is_Word_char(str[pos]) && is_Word_char(str[pos + 1])) { // if we have a delimiter followed by a Word char, we have a left boundary left of the Word char return (boundary_t){.type = E_BOUNDARY_TYPE_LEFT, .pos = pos + 1}; } else if (is_Word_char(str[pos]) && !is_Word_char(str[pos + 1])) { // if we have a Word char followed by a delimiter, we have a right boundary right of the Word char return (boundary_t){.type = E_BOUNDARY_TYPE_RIGHT, .pos = pos + 1}; } return (boundary_t){.type = E_BOUNDARY_TYPE_NONE}; } } int main() { string str; getline(cin, str); int len = str.length(); for (int i = 0; i < len; i++) { boundary_t boundary = maybe_Word_boundary(str, i); if (boundary.type == E_BOUNDARY_TYPE_LEFT) { // whatever } else if (boundary.type == E_BOUNDARY_TYPE_RIGHT) { // whatever } } }

見てわかるように、コードは理解するのが非常に簡単で微調整します、そしてコードの実際の使用法は非常に短くて簡単です。たとえそれがSTLを使用しないことを意味していても、C++を使用することで、可能な限り最も簡単でカスタマイズが容易なコードを書くことを止めるべきではありません。これは、Linus Torvaldsが "taste" と呼んでいるもののインスタンスだと思うでしょう。対処する必要が生じた場合.

このコードを改善できるのは、enum classを直接呼び出してラムダを渡す代わりに、is_Word_charでmaybe_Word_boundaryへの関数ポインタを受け取るis_Word_charの使用です。

Kakashi · Answer

@Jairo Abdiel Toribio Cisnerosありがとうございます。それは私のために働くがあなたの関数はいくつかの空の要素を返す。それで、空のないリターンのために、私は以下で編集しました：

std::vector<std::string> split(std::string str, const char* delim) { std::vector<std::string> v; std::string tmp; for(std::string::const_iterator i = str.begin(); i <= str.end(); ++i) { if(*i != *delim && i != str.end()) { tmp += *i; } else { if (tmp.length() > 0) { v.Push_back(tmp); } tmp = ""; } } return v; }

使用方法

std::string s = "one:two::three"; std::string delim = ":"; std::vector<std::string> vv = split(s, delim.c_str());

小文件 · Answer

私のstringとu32string〜の実装は、boost::algorithm::splitシグネチャを使っています。

template<typename CharT, typename UnaryPredicate> void split(std::vector<std::basic_string<CharT>>& split_result, const std::basic_string<CharT>& s, UnaryPredicate predicate) { using ST = std::basic_string<CharT>; using std::swap; std::vector<ST> tmp_result; auto iter = s.cbegin(), end_iter = s.cend(); while (true) { /** * Edge case: empty str -> Push an empty str and exit. */ auto find_iter = find_if(iter, end_iter, predicate); tmp_result.emplace_back(iter, find_iter); if (find_iter == end_iter) { break; } iter = ++find_iter; } swap(tmp_result, split_result); } template<typename CharT> void split(std::vector<std::basic_string<CharT>>& split_result, const std::basic_string<CharT>& s, const std::basic_string<CharT>& char_candidate) { std::unordered_set<CharT> candidate_set(char_candidate.cbegin(), char_candidate.cend()); auto predicate = [&candidate_set](const CharT& c) { return candidate_set.count(c) > 0U; }; return split(split_result, s, predicate); } template<typename CharT> void split(std::vector<std::basic_string<CharT>>& split_result, const std::basic_string<CharT>& s, const CharT* literals) { return split(split_result, s, std::basic_string<CharT>(literals)); }

Oleg · Answer

#include <iostream> #include <string> #include <deque> std::deque<std::string> split( const std::string& line, std::string::value_type delimiter, bool skipEmpty = false ) { std::deque<std::string> parts{}; if (!skipEmpty && !line.empty() && delimiter == line.at(0)) { parts.Push_back({}); } for (const std::string::value_type& c : line) { if ( ( c == delimiter && (skipEmpty ? (!parts.empty() && !parts.back().empty()) : true) ) || (c != delimiter && parts.empty()) ) { parts.Push_back({}); } if (c != delimiter) { parts.back().Push_back(c); } } if (skipEmpty && !parts.empty() && parts.back().empty()) { parts.pop_back(); } return parts; } void test(const std::string& line) { std::cout << line << std::endl; std::cout << "skipEmpty=0 |"; for (const std::string& part : split(line, ':')) { std::cout << part << '|'; } std::cout << std::endl; std::cout << "skipEmpty=1 |"; for (const std::string& part : split(line, ':', true)) { std::cout << part << '|'; } std::cout << std::endl; std::cout << std::endl; } int main() { test("foo:bar:::baz"); test(""); test("foo"); test(":"); test("::"); test(":foo"); test("::foo"); test(":foo:"); test(":foo::"); return 0; }

出力：

foo:bar:::baz skipEmpty=0 |foo|bar|||baz| skipEmpty=1 |foo|bar|baz| skipEmpty=0 | skipEmpty=1 | foo skipEmpty=0 |foo| skipEmpty=1 |foo| : skipEmpty=0 ||| skipEmpty=1 | :: skipEmpty=0 |||| skipEmpty=1 | :foo skipEmpty=0 ||foo| skipEmpty=1 |foo| ::foo skipEmpty=0 |||foo| skipEmpty=1 |foo| :foo: skipEmpty=0 ||foo|| skipEmpty=1 |foo| :foo:: skipEmpty=0 ||foo||| skipEmpty=1 |foo|

h.o.m.a.n · Answer

あなたがいくつかの文字で分割された文字列が欲しいなら、あなたは使うことができます

#include<iostream> #include<string> #include<vector> #include<iterator> #include<sstream> #include<string> using namespace std; void replaceOtherChars(string &input, vector<char> &dividers) { const char divider = dividers.at(0); int replaceIndex = 0; vector<char>::iterator it_begin = dividers.begin()+1, it_end= dividers.end(); for(;it_begin!=it_end;++it_begin) { replaceIndex = 0; while(true) { replaceIndex=input.find_first_of(*it_begin,replaceIndex); if(replaceIndex==-1) break; input.at(replaceIndex)=divider; } } } vector<string> split(string str, vector<char> chars, bool missEmptySpace =true ) { vector<string> result; const char divider = chars.at(0); replaceOtherChars(str,chars); stringstream stream; stream<<str; string temp; while(getline(stream,temp,divider)) { if(missEmptySpace && temp.empty()) continue; result.Push_back(temp); } return result; } int main() { string str ="milk, pigs.... hot-dogs "; vector<char> arr; arr.Push_back(' '); arr.Push_back(','); arr.Push_back('.'); vector<string> result = split(str,arr); vector<string>::iterator it_begin= result.begin(), it_end= result.end(); for(;it_begin!=it_end;++it_begin) { cout<<*it_begin<<endl; } return 0; }

hkBattousai · Answer

私の実装は代替ソリューションになることができます：

std::vector<std::wstring> SplitString(const std::wstring & String, const std::wstring & Seperator) { std::vector<std::wstring> Lines; size_t stSearchPos = 0; size_t stFoundPos; while (stSearchPos < String.size() - 1) { stFoundPos = String.find(Seperator, stSearchPos); stFoundPos = (stFoundPos == std::string::npos) ? String.size() : stFoundPos; Lines.Push_back(String.substr(stSearchPos, stFoundPos - stSearchPos)); stSearchPos = stFoundPos + Seperator.size(); } return Lines; }

テストコード：

std::wstring MyString(L"Part 1SEPsecond partSEPlast partSEPend"); std::vector<std::wstring> Parts = IniFile::SplitString(MyString, L"SEP"); std::wcout << L"The string: " << MyString << std::endl; for (std::vector<std::wstring>::const_iterator it=Parts.begin(); it<Parts.end(); ++it) { std::wcout << *it << L"<---" << std::endl; } std::wcout << std::endl; MyString = L"this,time,a,comma separated,string"; std::wcout << L"The string: " << MyString << std::endl; Parts = IniFile::SplitString(MyString, L","); for (std::vector<std::wstring>::const_iterator it=Parts.begin(); it<Parts.end(); ++it) { std::wcout << *it << L"<---" << std::endl; }

テストコードの出力

The string: Part 1SEPsecond partSEPlast partSEPend Part 1<--- second part<--- last part<--- end<--- The string: this,time,a,comma separated,string this<--- time<--- a<--- comma separated<--- string<---

Jonny · Answer

これはトップ答えの1つの拡張です。現在、返される要素の最大数Nの設定がサポートされています。文字列の最後のビットはN番目の要素になります。 MAXELEMENTSパラメータはオプションで、デフォルトの0に設定されていると、 無制限 の要素数が返されます。 :-)

.h：

class Myneatclass { public: static std::vector<std::string>& split(const std::string &s, char delim, std::vector<std::string> &elems, const size_t MAXELEMENTS = 0); static std::vector<std::string> split(const std::string &s, char delim, const size_t MAXELEMENTS = 0); };

.cpp：

std::vector<std::string>& Myneatclass::split(const std::string &s, char delim, std::vector<std::string> &elems, const size_t MAXELEMENTS) { std::stringstream ss(s); std::string item; while (std::getline(ss, item, delim)) { elems.Push_back(item); if (MAXELEMENTS > 0 && !ss.eof() && elems.size() + 1 >= MAXELEMENTS) { std::getline(ss, item); elems.Push_back(item); break; } } return elems; } std::vector<std::string> Myneatclass::split(const std::string &s, char delim, const size_t MAXELEMENTS) { std::vector<std::string> elems; split(s, delim, elems, MAXELEMENTS); return elems; }

Richard Hodges · Answer

ここのパーティーには非常に遅刻しますが、私はあなたが空白文字ではなく一連のデリミタを与えられ、標準ライブラリ以外のものを使用しない場合にこれをする最もエレガントな方法を考えていました。

これが私の考えです：

一連の区切り文字で単語を文字列ベクトルに分割するには、次の手順を実行します。

template<class Container> std::vector<std::string> split_by_delimiters(const std::string& input, const Container& delimiters) { std::vector<std::string> result; for (auto current = begin(input) ; current != end(input) ; ) { auto first = find_if(current, end(input), not_in(delimiters)); if (first == end(input)) break; auto last = find_if(first, end(input), is_in(delimiters)); result.emplace_back(first, last); current = last; } return result; }

別の方法で分割するには、有効な文字のシーケンスを提供します。

template<class Container> std::vector<std::string> split_by_valid_chars(const std::string& input, const Container& valid_chars) { std::vector<std::string> result; for (auto current = begin(input) ; current != end(input) ; ) { auto first = find_if(current, end(input), is_in(valid_chars)); if (first == end(input)) break; auto last = find_if(first, end(input), not_in(valid_chars)); result.emplace_back(first, last); current = last; } return result; }

is_inとnot_inは次のように定義されています。

namespace detail { template<class Container> struct is_in { is_in(const Container& charset) : _charset(charset) {} bool operator()(char c) const { return find(begin(_charset), end(_charset), c) != end(_charset); } const Container& _charset; }; template<class Container> struct not_in { not_in(const Container& charset) : _charset(charset) {} bool operator()(char c) const { return find(begin(_charset), end(_charset), c) == end(_charset); } const Container& _charset; }; } template<class Container> detail::not_in<Container> not_in(const Container& c) { return detail::not_in<Container>(c); } template<class Container> detail::is_in<Container> is_in(const Container& c) { return detail::is_in<Container>(c); }