据我所知,C++ 只允许将 2 个字符串加在一起,即:
s = s1 + s2
但是我怎样才能将许多字符串加在一起呢?像:
s = s1 + s2 + s3 + s4 + ... + sn
如果您尝试附加 std::string 类的字符串对象,这应该可以。
string s1 = "string1";
string s2 = "string2";
string s3 = "string3";
string s = s1 + s2 + s3;
或者
string s = string("s1") + string("s2") + string("s3") ...
首先,你可以做 +sn 的事情就好了。虽然假设您在 C++03 上使用字符串,但它会花费指数二次(见评论)时间。std::basic_string<t>
您可以使用std::basic_string<t>::append
in Concert withstd::basic_string<t>::reserve
在 O(n) 时间内连接您的字符串。
编辑:例如
string a;
//either
a.append(s1).append(s2).append(s3);
//or
a.append("I'm a string!").append("I am another string!");
s = s1 + s2 + s3 + .. + sn;
尽管它可以创建很多临时变量(一个好的优化编译器应该会有所帮助),但它会起作用,因为它会被有效地解释为:
string tmp1 = s1 + s2;
string tmp2 = tmp1 + s3;
string tmp3 = tmp2 + s4;
...
s = tmpn + sn;
保证不会创建临时对象的另一种方法是:
s = s1;
s += s2;
s += s3;
...
s += sn;
std::ostringstream
是为此而构建的,请参见此处的示例。这简单:
std::ostringstream out;
out << "a" << "b" << "c" << .... << "z";
std::string str( out.str());
使用模板添加字符串,char* 和 char's 组成字符串
斯特伦:-
#include <iostream>
#include <cstring>
// it_pair to wrap a pair of iterators for a for(:) loop
template<typename IT>
class it_pair
{
IT b;
IT e;
public:
auto begin() const
{
return b;
}
auto end() const
{
return e;
}
};
// string length
template<typename S> auto strlen(const S& s) -> decltype(s.size())
{
return s.size();
}
auto strlen(char c) -> size_t
{
return 1u;
}
auto strlen(const std::initializer_list<char>& il) -> size_t
{
return il.size();
}
template<typename IT>
auto strlen(const it_pair<IT>& p)
{
auto len = size_t{};
for(const auto& s:p)
len += strlen(s);
return len;
}
template<typename S, typename ...SS> auto strlen(S s, SS&... ss) -> size_t
{
return strlen(s) + strlen(ss...);
}
附加字符串
// terminate recursion
template<typename TA, typename TB>
void append(TA& a, TB& b)
{
a.append(b);
}
// special case for a character
template<>
void append<std::string, const char>(std::string& a, const char& b)
{
a.append(1, b);
}
// special case for a collection of strings
template<typename TA, typename TB>
void append(TA& a, const it_pair<TB>& p)
{
for(const auto& x: p)
a.append(x);
}
// recursion append
template<typename TA, typename TB, typename ...TT>
void append(TA& a, TB& b, TT&... tt)
{
append(a, b);
append(a, tt...);
}
template<typename ...TT>
std::string string_add(const TT& ... tt)
{
std::string s;
s.reserve(strlen(tt...));
append(s, tt...);
return s;
}
template<typename IT>
auto make_it_pair(IT b, IT e)
{
return it_pair<IT>{b, e};
}
template<typename T>
auto make_it_pair(const T& t)
{
using namespace std;
return make_it_pair(cbegin(t), cend(t));
}
主要例子
int main()
{
const char * s[] = {"vw", "xyz"};
std::vector<std::string> v{"l", "mn", "opqr"};
std::string a("a");
std::string b("bc");
std::string c("def");
std::cout << string_add(a, b+c, "ghij", make_it_pair(v), 'k', make_it_pair(s));
}
如果你想能够做到这一点
然后这将完成这项工作
auto s = std::string(s1).append(s2).append(s3).append(sn);
如果你喜欢格式很好的东西
auto s = std::string(s1).append(s2)
.append(s3)
.append(sn)