文字列のベクトルを文字列に分解する最もエレガントな方法を探しています。以下は、私が現在使用しているソリューションです。
static std::string& implode(const std::vector<std::string>& elems, char delim, std::string& s)
{
for (std::vector<std::string>::const_iterator ii = elems.begin(); ii != elems.end(); ++ii)
{
s += (*ii);
if ( ii + 1 != elems.end() ) {
s += delim;
}
}
return s;
}
static std::string implode(const std::vector<std::string>& elems, char delim)
{
std::string s;
return implode(elems, delim, s);
}
他に何かありますか?
boost::algorithm::join(..)
を使用します。
#include <boost/algorithm/string/join.hpp>
...
std::string joinedString = boost::algorithm::join(elems, delim);
この質問 も参照してください。
std::vector<std::string> strings;
const char* const delim = ", ";
std::ostringstream imploded;
std::copy(strings.begin(), strings.end(),
std::ostream_iterator<std::string>(imploded, delim));
(<string>
、<vector>
、<sstream>
および<iterator>
を含む)
_std::ostringstream
_ではなく_std::string
_を使用して出力を構築する必要があります(その後、そのstr()
メソッドを呼び出して文字列を取得できるため、インターフェイスを変更する必要はありません。一時的なs
)。
そこから、次のように_std::ostream_iterator
_を使用するように変更できます。
_copy(elems.begin(), elems.end(), ostream_iterator<string>(s, delim));
_
しかし、これには2つの問題があります。
delim
は、単一のchar
ではなく、_const char*
_である必要があります。大きな問題ではない。std::ostream_iterator
_は、最後を含むすべての単一要素の後に区切り文字を書き込みます。そのため、最後の最後のものを消去するか、この煩わしさのない独自バージョンのイテレータを作成する必要があります。このようなことを必要とするコードがたくさんある場合は、後者を行う価値があります。そうでなければ、混乱全体を避けるのが最善です(つまり、ostringstream
を使用しますが、_ostream_iterator
_は使用しません)。私はワンライナーを愛しているので(最後に見るように、あらゆる種類の奇妙なものに非常に役立ちます)、ここにstd :: accumulateとC++ 11 lambdaを使用したソリューションがあります。
std::accumulate(alist.begin(), alist.end(), std::string(),
[](const std::string& a, const std::string& b) -> std::string {
return a + (a.length() > 0 ? "," : "") + b;
} )
この構文は、単純な文字列結合を行うためだけに、ストリーム演算子のあらゆる種類の奇妙なロジックをストリーム操作の範囲外にしたくないストリーム演算子で役立ちます。たとえば、ストリーム演算子を使用して(std;を使用して)文字列をフォーマットするメソッドからの次のreturnステートメントを考えてみましょう。
return (dynamic_cast<ostringstream&>(ostringstream()
<< "List content: " << endl
<< std::accumulate(alist.begin(), alist.end(), std::string(),
[](const std::string& a, const std::string& b) -> std::string {
return a + (a.length() > 0 ? "," : "") + b;
} ) << endl
<< "Maybe some more stuff" << endl
)).str();
string join(const vector<string>& vec, const char* delim)
{
stringstream res;
copy(vec.begin(), vec.end(), ostream_iterator<string>(res, delim));
return res.str();
}
特に大きなコレクションでは、最初の要素がまだ追加されているかどうかを確認する必要はありません。
したがって、空のリストまたは単一要素のリストの場合、反復はまったくありません。
空の範囲は簡単です。 ""を返します。
単一要素または複数要素は、accumulate
によって完全に処理できます。
auto join = [](const auto &&range, const auto separator) {
if (range.empty()) return std::string();
return std::accumulate(
next(begin(range)), // there is at least 1 element, so OK.
end(range),
range[0], // the initial value
[&separator](auto result, const auto &value) {
return result + separator + value;
});
};
実行サンプル(require C++ 14): http://cpp.sh/8uspd
std::accumulate
を使用するバージョン:
#include <numeric>
#include <iostream>
#include <string>
struct infix {
std::string sep;
infix(const std::string& sep) : sep(sep) {}
std::string operator()(const std::string& lhs, const std::string& rhs) {
std::string rz(lhs);
if(!lhs.empty() && !rhs.empty())
rz += sep;
rz += rhs;
return rz;
}
};
int main() {
std::string a[] = { "Hello", "World", "is", "a", "program" };
std::string sum = std::accumulate(a, a+5, std::string(), infix(", "));
std::cout << sum << "\n";
}
この一部を使用すると answer に別の質問が追加され、末尾のコンマなしの区切り文字に基づいて、
使用法:
std::vector<std::string> input_str = std::vector<std::string>({"a", "b", "c"});
std::string result = string_join(input_str, ",");
printf("%s", result.c_str());
/// a,b,c
コード:
std::string string_join(const std::vector<std::string>& elements, const char* const separator)
{
switch (elements.size())
{
case 0:
return "";
case 1:
return elements[0];
default:
std::ostringstream os;
std::copy(elements.begin(), elements.end() - 1, std::ostream_iterator<std::string>(os, separator));
os << *elements.rbegin();
return os.str();
}
}
最後の要素の後に区切り文字を追加しない別の例を次に示します。
std::string concat_strings(const std::vector<std::string> &elements,
const std::string &separator)
{
if (!elements.empty())
{
std::stringstream ss;
auto it = elements.cbegin();
while (true)
{
ss << *it++;
if (it != elements.cend())
ss << separator;
else
return ss.str();
}
}
return "";
単純な愚かな解決策はどうですか?
std::string String::join(const std::vector<std::string> &lst, const std::string &delim)
{
std::string ret;
for(const auto &s : lst) {
if(!ret.empty())
ret += delim;
ret += s;
}
return ret;
}
ここに私が使用するもの、シンプルで柔軟なもの
string joinList(vector<string> arr, string delimiter)
{
if (arr.empty()) return "";
string str;
for (auto i : arr)
str += i + delimiter;
str = str.substr(0, str.size() - delimiter.size());
return str;
}
を使用して:
string a = joinList({ "a", "bbb", "c" }, "!@#");
出力:
a!@#bbb!@#c
第一に、ストリームクラスostringstream
は、ここで何回も連結を行い、過剰なメモリ割り当ての根本的な問題を回避するために必要です。
コード:
_string join(const vector<string>& vec, const char* delim)
{
ostringstream oss;
if(!string_vector.empty()) {
copy(string_vector.begin(),string_vector.end() - 1, ostream_iterator<string>(oss, delim.c_str()));
}
return oss.str();
}
vector<string> string_vector {"1", "2"};
string delim("->");
string joined_string = join(); // get "1->2"
_
説明:
考えるとき、ここでoss
を_std::cout
_として扱う
書きたいとき:
_std::cout << string_vector[0] << "->" << string_vector[1] << "->"
_、
次のSTLクラスをヘルプとして使用できます。
_ostream_iterator
_は、_<<
_を使用するたびに区切り文字が自動的に追加されたラップされた出力ストリームを返します。
例えば、
ostream my_cout = ostream_iterator<string>(std::cout, "->")
_std:cout
_を_my_cout
_としてラップします
毎回_my_cout << "string_vector[0]"
_、
_std::cout << "string_vector[0]" << "->"
_を意味します
copy(vector.begin(), vector.end(), std::out);
について
std::cout << vector[0] << vector[1] (...) << vector[end]
を意味します
追加するだけ!!文字列s = "";
for (int i = 0; i < doc.size(); i++) //doc is the vector
s += doc[i];
少し長いソリューションですが、std::ostringstream
を使用せず、最後の区切り文字を削除するためにハックを必要としません。
そしてコード:
struct appender
{
appender(char d, std::string& sd, int ic) : delim(d), dest(sd), count(ic)
{
dest.reserve(2048);
}
void operator()(std::string const& copy)
{
dest.append(copy);
if (--count)
dest.append(1, delim);
}
char delim;
mutable std::string& dest;
mutable int count;
};
void implode(const std::vector<std::string>& elems, char delim, std::string& s)
{
std::for_each(elems.begin(), elems.end(), appender(delim, s, elems.size()));
}
これを試してくださいが、リストの代わりにベクトルを使用してください
template <class T>
std::string listToString(std::list<T> l){
std::stringstream ss;
for(std::list<int>::iterator it = l.begin(); it!=l.end(); ++it){
ss << *it;
if(std::distance(it,l.end())>1)
ss << ", ";
}
return "[" + ss.str()+ "]";
}