Javaには便利な分割メソッドがあります。
String str = "The quick brown fox";
String[] results = str.split(" ");
C ++でこれを行う簡単な方法はありますか?
Javaには便利な分割メソッドがあります。
String str = "The quick brown fox";
String[] results = str.split(" ");
C ++でこれを行う簡単な方法はありますか?
回答:
C ++標準ライブラリアルゴリズムは、具体的には、具体的なコンテナーではなく、イテレーターをベースにしています。残念ながら、これはsplit
C ++標準ライブラリでJavaのような関数を提供することを困難にします。しかし、その戻り値の型はどうなるでしょうか?std::vector<std::basic_string<…>>
?たぶん、それでも私たちは(潜在的に冗長でコストのかかる)割り当てを実行せざるを得ません。
代わりに、C ++は、任意の複雑な区切り文字に基づいて文字列を分割するための多くの方法を提供しますが、他の言語ほどうまくカプセル化されていません。ブログ投稿全体を埋めるさまざまな方法があります。
最も単純な場合、を押すstd::string::find
までを使用して繰り返しstd::string::npos
、を使用してコンテンツを抽出できますstd::string::substr
。
空白で分割するための複数の流体(および慣用的な、基本的な)バージョンが使用しますstd::istringstream
:
auto iss = std::istringstream{"The quick brown fox"};
auto str = std::string{};
while (iss >> str) {
process(str);
}
std::istream_iterator
sを使用すると、文字列ストリームの内容を、そのイテレーター範囲コンストラクターを使用してベクターにコピーすることもできます。
複数のライブラリー(Boost.Tokenizerなど)は、特定のトークナイザーを提供します。
より高度な分割には正規表現が必要です。C ++は、std::regex_token_iterator
特にこの目的のためにを提供します。
auto const str = "The quick brown fox"s;
auto const re = std::regex{R"(\s+)"};
auto const vec = std::vector<std::string>(
std::sregex_token_iterator{begin(str), end(str), re, -1},
std::sregex_token_iterator{}
);
トークナイザブーストクラスは、この種のものは、非常にシンプルにすることができます。
#include <iostream>
#include <string>
#include <boost/foreach.hpp>
#include <boost/tokenizer.hpp>
using namespace std;
using namespace boost;
int main(int, char**)
{
string text = "token, test string";
char_separator<char> sep(", ");
tokenizer< char_separator<char> > tokens(text, sep);
BOOST_FOREACH (const string& t, tokens) {
cout << t << "." << endl;
}
}
C ++ 11用に更新:
#include <iostream>
#include <string>
#include <boost/tokenizer.hpp>
using namespace std;
using namespace boost;
int main(int, char**)
{
string text = "token, test string";
char_separator<char> sep(", ");
tokenizer<char_separator<char>> tokens(text, sep);
for (const auto& t : tokens) {
cout << t << "." << endl;
}
}
char_separator
コンストラクタの3番目のパラメータに注意してください(これdrop_empty_tokens
がデフォルトですが、代わりはですkeep_empty_tokens
)。
.h
Cヘッダーの場合と同様)
これが本当にシンプルなものです:
#include <vector>
#include <string>
using namespace std;
vector<string> split(const char *str, char c = ' ')
{
vector<string> result;
do
{
const char *begin = str;
while(*str != c && *str)
str++;
result.push_back(string(begin, str));
} while (0 != *str++);
return result;
}
strtokを使用します。私の意見では、strtokが必要なものを提供しない限り、トークン化に関するクラスを構築する必要はありません。そうではないかもしれませんが、CおよびC ++でさまざまな解析コードを作成してから15年以上の間、私は常にstrtokを使用してきました。ここに例があります
char myString[] = "The quick brown fox";
char *p = strtok(myString, " ");
while (p) {
printf ("Token: %s\n", p);
p = strtok(NULL, " ");
}
いくつかの注意事項(ニーズに合わない場合があります)。文字列はプロセスで「破棄」されます。つまり、EOS文字がデリミタスポットにインラインで配置されます。正しい使用法では、文字列を非constバージョンにする必要があります。解析中に区切り文字のリストを変更することもできます。
私の意見では、上記のコードは、別のクラスを記述するよりもはるかに単純で使いやすいです。私にとって、これは言語が提供する機能の1つであり、それがうまく、きれいに行われます。それは単に「Cベースの」ソリューションです。それは適切で、簡単で、多くの追加コードを書く必要はありません:-)
別の簡単な方法は、を使用することgetline
です。何かのようなもの:
stringstream ss("bla bla");
string s;
while (getline(ss, s, ' ')) {
cout << s << endl;
}
必要に応じて、をsplit()
返す簡単なメソッドを作成できますvector<string>
。これは非常に便利です。
ストリーム、イテレータ、コピーアルゴリズムを使用して、これをかなり直接行うことができます。
#include <string>
#include <vector>
#include <iostream>
#include <istream>
#include <ostream>
#include <iterator>
#include <sstream>
#include <algorithm>
int main()
{
std::string str = "The quick brown fox";
// construct a stream from the string
std::stringstream strstr(str);
// use stream iterators to copy the stream to the vector as whitespace separated strings
std::istream_iterator<std::string> it(strstr);
std::istream_iterator<std::string> end;
std::vector<std::string> results(it, end);
// send the vector to stdout.
std::ostream_iterator<std::string> oit(std::cout);
std::copy(results.begin(), results.end(), oit);
}
std
は、オブジェクトがどこから来たのかをこのように知ることを好みます。それは単にスタイルの問題です。
悪気の人々は、しかし、このような単純な問題のために、あなたは物事を作るされていない方法が複雑すぎます。Boostを使用する理由はたくさんあります。しかし、これほど単純なものについては、20#のそりでフライを打つようなものです。
void
split( vector<string> & theStringVector, /* Altered/returned value */
const string & theString,
const string & theDelimiter)
{
UASSERT( theDelimiter.size(), >, 0); // My own ASSERT macro.
size_t start = 0, end = 0;
while ( end != string::npos)
{
end = theString.find( theDelimiter, start);
// If at end, use length=maxLength. Else use length=end-start.
theStringVector.push_back( theString.substr( start,
(end == string::npos) ? string::npos : end - start));
// If at end, use start=maxSize. Else use start=end+delimiter.
start = ( ( end > (string::npos - theDelimiter.size()) )
? string::npos : end + theDelimiter.size());
}
}
たとえば(ダグの場合)、
#define SHOW(I,X) cout << "[" << (I) << "]\t " # X " = \"" << (X) << "\"" << endl
int
main()
{
vector<string> v;
split( v, "A:PEP:909:Inventory Item", ":" );
for (unsigned int i = 0; i < v.size(); i++)
SHOW( i, v[i] );
}
そして、はい、split()でベクトルを渡すのではなく、新しいベクトルを返すようにすることもできます。ラップしてオーバーロードするのは簡単です。しかし、私が何をしているのかによっては、常に新しいオブジェクトを作成するよりも、既存のオブジェクトを再利用する方がよいことがよくあります。(その間にベクターを空にするのを忘れない限り!)
リファレンス:http : //www.cplusplus.com/reference/string/string/。
(もともとはDougの質問に対する回答を書いていました:セパレーターに基づくC ++文字列の変更と抽出(終了)。しかし、Martin Yorkはここにポインターを置いて質問を終了したので、コードを一般化します。)
std::string
クラスにsplit()関数が含まれていないのですか?
start = ((end > (theString.size() - theDelimiter.size())) ? string::npos : end + theDelimiter.size());
ますwhile (start != string::npos)
。また、ベクターに挿入する前に、部分文字列が空でないことを確認します。
regex_token_iterator
s を使用したソリューション:
#include <iostream>
#include <regex>
#include <string>
using namespace std;
int main()
{
string str("The quick brown fox");
regex reg("\\s+");
sregex_token_iterator iter(str.begin(), str.end(), reg, -1);
sregex_token_iterator end;
vector<string> vec(iter, end);
for (auto a : vec)
{
cout << a << endl;
}
}
Boostには強力なスプリット関数があります:boost :: algorithm :: split。
サンプルプログラム:
#include <vector>
#include <boost/algorithm/string.hpp>
int main() {
auto s = "a,b, c ,,e,f,";
std::vector<std::string> fields;
boost::split(fields, s, boost::is_any_of(","));
for (const auto& field : fields)
std::cout << "\"" << field << "\"\n";
return 0;
}
出力:
"a"
"b"
" c "
""
"e"
"f"
""
これはあなたが望むことをするかもしれないサンプルトークナイザークラスです
//Header file
class Tokenizer
{
public:
static const std::string DELIMITERS;
Tokenizer(const std::string& str);
Tokenizer(const std::string& str, const std::string& delimiters);
bool NextToken();
bool NextToken(const std::string& delimiters);
const std::string GetToken() const;
void Reset();
protected:
size_t m_offset;
const std::string m_string;
std::string m_token;
std::string m_delimiters;
};
//CPP file
const std::string Tokenizer::DELIMITERS(" \t\n\r");
Tokenizer::Tokenizer(const std::string& s) :
m_string(s),
m_offset(0),
m_delimiters(DELIMITERS) {}
Tokenizer::Tokenizer(const std::string& s, const std::string& delimiters) :
m_string(s),
m_offset(0),
m_delimiters(delimiters) {}
bool Tokenizer::NextToken()
{
return NextToken(m_delimiters);
}
bool Tokenizer::NextToken(const std::string& delimiters)
{
size_t i = m_string.find_first_not_of(delimiters, m_offset);
if (std::string::npos == i)
{
m_offset = m_string.length();
return false;
}
size_t j = m_string.find_first_of(delimiters, i);
if (std::string::npos == j)
{
m_token = m_string.substr(i);
m_offset = m_string.length();
return true;
}
m_token = m_string.substr(i, j - i);
m_offset = j;
return true;
}
例:
std::vector <std::string> v;
Tokenizer s("split this string", " ");
while (s.NextToken())
{
v.push_back(s.GetToken());
}
これはシンプルなSTLのみのソリューション(〜5行!)を使用std::find
しstd::find_first_not_of
、区切り文字の繰り返し(スペースやピリオドなど)と先頭と末尾の区切り文字を処理します。
#include <string>
#include <vector>
void tokenize(std::string str, std::vector<string> &token_v){
size_t start = str.find_first_not_of(DELIMITER), end=start;
while (start != std::string::npos){
// Find next occurence of delimiter
end = str.find(DELIMITER, start);
// Push back the token found into vector
token_v.push_back(str.substr(start, end-start));
// Skip all occurences of the delimiter to find new start
start = str.find_first_not_of(DELIMITER, end);
}
}
ライブでお試しください!
pystringは、splitメソッドを含む、Pythonの文字列関数の束を実装する小さなライブラリです。
#include <string>
#include <vector>
#include "pystring.h"
std::vector<std::string> chunks;
pystring::split("this string", chunks);
// also can specify a separator
pystring::split("this-string", chunks, "-");
同様の質問にこの回答を投稿しました。
車輪を再発明しないでください。私はいくつかのライブラリを使用してきましたが、出会った中で最も速くて最も柔軟なのは C ++ String Toolkit Libraryです。
これは、stackoverflowの他の場所に投稿した使用方法の例です。
#include <iostream>
#include <vector>
#include <string>
#include <strtk.hpp>
const char *whitespace = " \t\r\n\f";
const char *whitespace_and_punctuation = " \t\r\n\f;,=";
int main()
{
{ // normal parsing of a string into a vector of strings
std::string s("Somewhere down the road");
std::vector<std::string> result;
if( strtk::parse( s, whitespace, result ) )
{
for(size_t i = 0; i < result.size(); ++i )
std::cout << result[i] << std::endl;
}
}
{ // parsing a string into a vector of floats with other separators
// besides spaces
std::string s("3.0, 3.14; 4.0");
std::vector<float> values;
if( strtk::parse( s, whitespace_and_punctuation, values ) )
{
for(size_t i = 0; i < values.size(); ++i )
std::cout << values[i] << std::endl;
}
}
{ // parsing a string into specific variables
std::string s("angle = 45; radius = 9.9");
std::string w1, w2;
float v1, v2;
if( strtk::parse( s, whitespace_and_punctuation, w1, v1, w2, v2) )
{
std::cout << "word " << w1 << ", value " << v1 << std::endl;
std::cout << "word " << w2 << ", value " << v2 << std::endl;
}
}
return 0;
}
この例を確認してください。それはあなたを助けるかもしれません。
#include <iostream>
#include <sstream>
using namespace std;
int main ()
{
string tmps;
istringstream is ("the dellimiter is the space");
while (is.good ()) {
is >> tmps;
cout << tmps << "\n";
}
return 0;
}
while ( is >> tmps ) { std::cout << tmps << "\n"; }
MFC / ATLには非常に優れたトークナイザーがあります。MSDNから:
CAtlString str( "%First Second#Third" );
CAtlString resToken;
int curPos= 0;
resToken= str.Tokenize("% #",curPos);
while (resToken != "")
{
printf("Resulting token: %s\n", resToken);
resToken= str.Tokenize("% #",curPos);
};
Output
Resulting Token: First
Resulting Token: Second
Resulting Token: Third
Cを使用する場合は、strtok関数を使用できます。使用する場合は、マルチスレッドの問題に注意する必要があります。
単純なものについては、私は以下を使用します:
unsigned TokenizeString(const std::string& i_source,
const std::string& i_seperators,
bool i_discard_empty_tokens,
std::vector<std::string>& o_tokens)
{
unsigned prev_pos = 0;
unsigned pos = 0;
unsigned number_of_tokens = 0;
o_tokens.clear();
pos = i_source.find_first_of(i_seperators, pos);
while (pos != std::string::npos)
{
std::string token = i_source.substr(prev_pos, pos - prev_pos);
if (!i_discard_empty_tokens || token != "")
{
o_tokens.push_back(i_source.substr(prev_pos, pos - prev_pos));
number_of_tokens++;
}
pos++;
prev_pos = pos;
pos = i_source.find_first_of(i_seperators, pos);
}
if (prev_pos < i_source.length())
{
o_tokens.push_back(i_source.substr(prev_pos));
number_of_tokens++;
}
return number_of_tokens;
}
臆病な免責事項:私は、バイナリファイル、ソケット、またはいくつかのAPI呼び出し(I / Oカード、カメラ)を介してデータを受信するリアルタイムデータ処理ソフトウェアを作成しています。起動時に外部構成ファイルを読み取るよりも複雑な、またはタイムクリティカルなものにこの関数を使用することはありません。
単純に正規表現ライブラリを使用できますをを使用してそれを解決ます。
式(\ w +)と\ 1(または正規表現のライブラリ実装に応じて$ 1)の変数を使用します。
ここには過度に複雑な提案がたくさんあります。この単純なstd :: stringソリューションを試してください:
using namespace std;
string someText = ...
string::size_type tokenOff = 0, sepOff = tokenOff;
while (sepOff != string::npos)
{
sepOff = someText.find(' ', sepOff);
string::size_type tokenLen = (sepOff == string::npos) ? sepOff : sepOff++ - tokenOff;
string token = someText.substr(tokenOff, tokenLen);
if (!token.empty())
/* do something with token */;
tokenOff = sepOff;
}
Adam Pierceの回答は、手で紡ぐトークナイザーを提供していconst char*
ます。の終了反復子のインクリメントstring
は定義されていないため、反復子を使用するのは少し問題があります。とstring str{ "The quick brown fox" }
はいえ、これを確実に達成できるとすれば、
auto start = find(cbegin(str), cend(str), ' ');
vector<string> tokens{ string(cbegin(str), start) };
while (start != cend(str)) {
const auto finish = find(++start, cend(str), ' ');
tokens.push_back(string(start, finish));
start = finish;
}
On Freundが示唆 しているように、標準機能を使用して複雑さを抽象化したい場合strtok
は、簡単なオプションです。
vector<string> tokens;
for (auto i = strtok(data(str), " "); i != nullptr; i = strtok(nullptr, " ")) tokens.push_back(i);
C ++ 17にアクセスできない場合はdata(str)
、次の例のように置き換える必要があります。。http //ideone.com/8kAGoa
例では示していませんが、strtok
各トークンに同じ区切り文字を使用する必要はありません。ただし、この利点に加えて、いくつかの欠点があります。
strtok
strings
同時に複数で使用することはできません。nullptr
現在のトークン化を続行するにはaを渡す必要があります。string
または、char*
tokenizeに新しいものを渡す必要があります(ただし、これをサポートする非標準の実装には次のようなものがあります:strtok_s
)。strtok
、複数のスレッドで同時に使用することはできません(ただし、これは実装によって定義される場合があります。たとえば、Visual Studioの実装はスレッドセーフです。)。strtok
修正をstring
上で使用することはできませんので、それは上で動作している、const string
S、const char*
とこれらのいずれかをトークン化するために、S、またはリテラル文字列strtok
または上で動作するstring
コンテンツが保存される必要があります誰が、str
可能性がコピーされなければならないだろう、そのコピー手術するc ++ 20split_view
非破壊的な方法で文字列をトークン化するために私たちに提供します:https : //topanswers.xyz/cplusplus?q =749#a874
以前のメソッドはトークン化さvector
れたインプレースを生成できません。つまり、初期化できないヘルパー関数にそれらを抽象化する必要がありますconst vector<string> tokens
。この機能と、任意の空白区切り文字を受け入れる機能は、を使用して利用できますistream_iterator
。たとえば、次のconst string str{ "The quick \tbrown \nfox" }
ことが可能です。
istringstream is{ str };
const vector<string> tokens{ istream_iterator<string>(is), istream_iterator<string>() };
istringstream
このオプションに必要な構築には、前の2つのオプションよりもはるかに大きなコストがかかりますが、このコストは通常、string
割り当ての費用に隠されています。
上記のオプションのいずれもトークン化のニーズに十分に柔軟ではない場合、最も柔軟なオプションはregex_token_iterator
もちろん、この柔軟性を備えたを使用するstring
ことです。たとえば、エスケープされていないカンマに基づいてトークン化したいとします。次の入力が与えられた場合、空白も食べます。const string str{ "The ,qu\\,ick ,\tbrown, fox" }
これを行うことができます:
const regex re{ "\\s*((?:[^\\\\,]|\\\\.)*?)\\s*(?:,|$)" };
const vector<string> tokens{ sregex_token_iterator(cbegin(str), cend(str), re, 1), sregex_token_iterator() };
strtok_s
ちなみにC11規格です。strtok_r
POSIX2001標準です。これらの両方の間にstrtok
、ほとんどのプラットフォーム用の標準の再入可能バージョンがあります。
#include <cstring>
のc99バージョンのみが含まれstrtok
ます。したがって、私の仮定は、このコメントをサポート資料として提供するだけであり、strtok
拡張機能の実装固有の可用性を実証しているということですか?
strtok_s
C11とMicrosoftのCランタイムのスタンドアロン拡張の両方で提供されます。ここには、Microsoftの_s
関数がC標準になったという興味深い奇妙な歴史があります。
この質問はすでに回答済みですが、貢献したいと思います。多分私の解決策は少しシンプルですが、これは私が思いついたものです:
vector<string> get_words(string const& text, string const& separator)
{
vector<string> result;
string tmp = text;
size_t first_pos = 0;
size_t second_pos = tmp.find(separator);
while (second_pos != string::npos)
{
if (first_pos != second_pos)
{
string word = tmp.substr(first_pos, second_pos - first_pos);
result.push_back(word);
}
tmp = tmp.substr(second_pos + separator.length());
second_pos = tmp.find(separator);
}
result.push_back(tmp);
return result;
}
私のコードの何かにより良いアプローチがあるか、何かが間違っている場合はコメントしてください。
更新:汎用セパレーターを追加
空のトークンを含める(strsepなど)か、除外する(strtokなど)かを制御できる方法を次に示します。
#include <string.h> // for strchr and strlen
/*
* want_empty_tokens==true : include empty tokens, like strsep()
* want_empty_tokens==false : exclude empty tokens, like strtok()
*/
std::vector<std::string> tokenize(const char* src,
char delim,
bool want_empty_tokens)
{
std::vector<std::string> tokens;
if (src and *src != '\0') // defensive
while( true ) {
const char* d = strchr(src, delim);
size_t len = (d)? d-src : strlen(src);
if (len or want_empty_tokens)
tokens.push_back( std::string(src, len) ); // capture token
if (d) src += len+1; else break;
}
return tokens;
}
ここで私たち全員がスピードを意識したオタクで、区切り文字用のコンパイル時生成ルックアップテーブルを使用するバージョンを提示した人はいません(実装例はさらに下)。ルックアップテーブルとイテレータを使用すると、効率的にstd :: regexに勝るはずです。正規表現に勝る必要がない場合は、それを使用してください。C++ 11の標準であり、非常に柔軟です。
一部の人はすでに正規表現を提案していますが、ここでの初心者のために、OPが期待することを正確に実行するパッケージ化された例を示します。
std::vector<std::string> split(std::string::const_iterator it, std::string::const_iterator end, std::regex e = std::regex{"\\w+"}){
std::smatch m{};
std::vector<std::string> ret{};
while (std::regex_search (it,end,m,e)) {
ret.emplace_back(m.str());
std::advance(it, m.position() + m.length()); //next start position = match position + match length
}
return ret;
}
std::vector<std::string> split(const std::string &s, std::regex e = std::regex{"\\w+"}){ //comfort version calls flexible version
return split(s.cbegin(), s.cend(), std::move(e));
}
int main ()
{
std::string str {"Some people, excluding those present, have been compile time constants - since puberty."};
auto v = split(str);
for(const auto&s:v){
std::cout << s << std::endl;
}
std::cout << "crazy version:" << std::endl;
v = split(str, std::regex{"[^e]+"}); //using e as delim shows flexibility
for(const auto&s:v){
std::cout << s << std::endl;
}
return 0;
}
すべての文字が8ビットでなければならないという制約を受け入れる必要がある場合は、コンパイル時にメタプログラミングを使用してルックアップテーブルを作成できます。
template<bool...> struct BoolSequence{}; //just here to hold bools
template<char...> struct CharSequence{}; //just here to hold chars
template<typename T, char C> struct Contains; //generic
template<char First, char... Cs, char Match> //not first specialization
struct Contains<CharSequence<First, Cs...>,Match> :
Contains<CharSequence<Cs...>, Match>{}; //strip first and increase index
template<char First, char... Cs> //is first specialization
struct Contains<CharSequence<First, Cs...>,First>: std::true_type {};
template<char Match> //not found specialization
struct Contains<CharSequence<>,Match>: std::false_type{};
template<int I, typename T, typename U>
struct MakeSequence; //generic
template<int I, bool... Bs, typename U>
struct MakeSequence<I,BoolSequence<Bs...>, U>: //not last
MakeSequence<I-1, BoolSequence<Contains<U,I-1>::value,Bs...>, U>{};
template<bool... Bs, typename U>
struct MakeSequence<0,BoolSequence<Bs...>,U>{ //last
using Type = BoolSequence<Bs...>;
};
template<typename T> struct BoolASCIITable;
template<bool... Bs> struct BoolASCIITable<BoolSequence<Bs...>>{
/* could be made constexpr but not yet supported by MSVC */
static bool isDelim(const char c){
static const bool table[256] = {Bs...};
return table[static_cast<int>(c)];
}
};
using Delims = CharSequence<'.',',',' ',':','\n'>; //list your custom delimiters here
using Table = BoolASCIITable<typename MakeSequence<256,BoolSequence<>,Delims>::Type>;
それができれば、getNextToken
関数の作成は簡単です。
template<typename T_It>
std::pair<T_It,T_It> getNextToken(T_It begin,T_It end){
begin = std::find_if(begin,end,std::not1(Table{})); //find first non delim or end
auto second = std::find_if(begin,end,Table{}); //find first delim or end
return std::make_pair(begin,second);
}
使い方も簡単です:
int main() {
std::string s{"Some people, excluding those present, have been compile time constants - since puberty."};
auto it = std::begin(s);
auto end = std::end(s);
while(it != std::end(s)){
auto token = getNextToken(it,end);
std::cout << std::string(token.first,token.second) << std::endl;
it = token.second;
}
return 0;
}
これが実際の例です:http : //ideone.com/GKtkLQ
boost :: make_find_iteratorを利用できます。これに似たもの:
template<typename CH>
inline vector< basic_string<CH> > tokenize(
const basic_string<CH> &Input,
const basic_string<CH> &Delimiter,
bool remove_empty_token
) {
typedef typename basic_string<CH>::const_iterator string_iterator_t;
typedef boost::find_iterator< string_iterator_t > string_find_iterator_t;
vector< basic_string<CH> > Result;
string_iterator_t it = Input.begin();
string_iterator_t it_end = Input.end();
for(string_find_iterator_t i = boost::make_find_iterator(Input, boost::first_finder(Delimiter, boost::is_equal()));
i != string_find_iterator_t();
++i) {
if(remove_empty_token){
if(it != i->begin())
Result.push_back(basic_string<CH>(it,i->begin()));
}
else
Result.push_back(basic_string<CH>(it,i->begin()));
it = i->end();
}
if(it != it_end)
Result.push_back(basic_string<CH>(it,it_end));
return Result;
}
これは、スペースで文字列を分割し、単一引用符と二重引用符で囲まれた文字列を考慮し、結果からこれらの文字を取り除くための文字列トークン化ツールのSwiss®Army Knifeです。RegexBuddy 4.xを使用してほとんどのコードスニペットを生成しましたが、引用符を取り除くためのカスタム処理やその他のいくつかを追加しました。
#include <string>
#include <locale>
#include <regex>
std::vector<std::wstring> tokenize_string(std::wstring string_to_tokenize) {
std::vector<std::wstring> tokens;
std::wregex re(LR"(("[^"]*"|'[^']*'|[^"' ]+))", std::regex_constants::collate);
std::wsregex_iterator next( string_to_tokenize.begin(),
string_to_tokenize.end(),
re,
std::regex_constants::match_not_null );
std::wsregex_iterator end;
const wchar_t single_quote = L'\'';
const wchar_t double_quote = L'\"';
while ( next != end ) {
std::wsmatch match = *next;
const std::wstring token = match.str( 0 );
next++;
if (token.length() > 2 && (token.front() == double_quote || token.front() == single_quote))
tokens.emplace_back( std::wstring(token.begin()+1, token.begin()+token.length()-1) );
else
tokens.emplace_back(token);
}
return tokens;
}
トークン化する入力文字列の最大長がわかっている場合は、これを利用して非常に高速なバージョンを実装できます。以下の基本的なアイデアをスケッチしています。これは、strtok()と、Jon Bentleyの「Programming Perls」第2版の第15章で説明されている「suffix array」データ構造の両方に触発されたものです。使用の。示された実装は、トークンの先頭と末尾の空白文字を削除するために簡単に拡張できます。
基本的に、区切り文字を文字列終端の「\ 0」文字に置き換え、変更された文字列を含むトークンへのポインタを設定できます。文字列がセパレータのみで構成される極端なケースでは、文字列長に1を加えた結果の空のトークンを取得します。変更する文字列を複製するのが実際的です。
ヘッダーファイル:
class TextLineSplitter
{
public:
TextLineSplitter( const size_t max_line_len );
~TextLineSplitter();
void SplitLine( const char *line,
const char sep_char = ',',
);
inline size_t NumTokens( void ) const
{
return mNumTokens;
}
const char * GetToken( const size_t token_idx ) const
{
assert( token_idx < mNumTokens );
return mTokens[ token_idx ];
}
private:
const size_t mStorageSize;
char *mBuff;
char **mTokens;
size_t mNumTokens;
inline void ResetContent( void )
{
memset( mBuff, 0, mStorageSize );
// mark all items as empty:
memset( mTokens, 0, mStorageSize * sizeof( char* ) );
// reset counter for found items:
mNumTokens = 0L;
}
};
実装ファイル:
TextLineSplitter::TextLineSplitter( const size_t max_line_len ):
mStorageSize ( max_line_len + 1L )
{
// allocate memory
mBuff = new char [ mStorageSize ];
mTokens = new char* [ mStorageSize ];
ResetContent();
}
TextLineSplitter::~TextLineSplitter()
{
delete [] mBuff;
delete [] mTokens;
}
void TextLineSplitter::SplitLine( const char *line,
const char sep_char /* = ',' */,
)
{
assert( sep_char != '\0' );
ResetContent();
strncpy( mBuff, line, mMaxLineLen );
size_t idx = 0L; // running index for characters
do
{
assert( idx < mStorageSize );
const char chr = line[ idx ]; // retrieve current character
if( mTokens[ mNumTokens ] == NULL )
{
mTokens[ mNumTokens ] = &mBuff[ idx ];
} // if
if( chr == sep_char || chr == '\0' )
{ // item or line finished
// overwrite separator with a 0-terminating character:
mBuff[ idx ] = '\0';
// count-up items:
mNumTokens ++;
} // if
} while( line[ idx++ ] );
}
使用シナリオは次のとおりです。
// create an instance capable of splitting strings up to 1000 chars long:
TextLineSplitter spl( 1000 );
spl.SplitLine( "Item1,,Item2,Item3" );
for( size_t i = 0; i < spl.NumTokens(); i++ )
{
printf( "%s\n", spl.GetToken( i ) );
}
出力:
Item1
Item2
Item3
boost::tokenizer
あなたの友達ですが、国際化(i18n)の問題を参照して、レガシー/ タイプの代わりにwstring
/ を使用してコードを移植可能にすることを検討してください。wchar_t
string
char
#include <iostream>
#include <boost/tokenizer.hpp>
#include <string>
using namespace std;
using namespace boost;
typedef tokenizer<char_separator<wchar_t>,
wstring::const_iterator, wstring> Tok;
int main()
{
wstring s;
while (getline(wcin, s)) {
char_separator<wchar_t> sep(L" "); // list of separator characters
Tok tok(s, sep);
for (Tok::iterator beg = tok.begin(); beg != tok.end(); ++beg) {
wcout << *beg << L"\t"; // output (or store in vector)
}
wcout << L"\n";
}
return 0;
}
wchar_t
、絶対に必要でない限り誰も使用してはならない恐ろしい実装依存型です。
単純なC ++コード(標準C ++ 98)、複数の区切り文字(std :: stringで指定)を受け入れ、ベクトル、文字列、および反復子のみを使用します。
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>
std::vector<std::string>
split(const std::string& str, const std::string& delim){
std::vector<std::string> result;
if (str.empty())
throw std::runtime_error("Can not tokenize an empty string!");
std::string::const_iterator begin, str_it;
begin = str_it = str.begin();
do {
while (delim.find(*str_it) == std::string::npos && str_it != str.end())
str_it++; // find the position of the first delimiter in str
std::string token = std::string(begin, str_it); // grab the token
if (!token.empty()) // empty token only when str starts with a delimiter
result.push_back(token); // push the token into a vector<string>
while (delim.find(*str_it) != std::string::npos && str_it != str.end())
str_it++; // ignore the additional consecutive delimiters
begin = str_it; // process the remaining tokens
} while (str_it != str.end());
return result;
}
int main() {
std::string test_string = ".this is.a.../.simple;;test;;;END";
std::string delim = "; ./"; // string containing the delimiters
std::vector<std::string> tokens = split(test_string, delim);
for (std::vector<std::string>::const_iterator it = tokens.begin();
it != tokens.end(); it++)
std::cout << *it << std::endl;
}