blocks|key|2193196|text|您可以使用<numeric>头中的std::accumulate()标准函数(它之所以有效，是因为为返回两个参数连接的strings定义了operator+%2B重载)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2193197|#include+<vector>
#include+<string>
#include+<numeric>
#include+<iostream>

int+main()
{
++++std::vector<std::string>+v{"Hello,+",+"+Cruel+",+"World!"};
++++std::string+s;
++++s+=+accumulate(begin(v),+end(v),+s);
++++std::cout+<<+s;+//+Will+print+"Hello,+Cruel+World!"
}|code-block|syntax|javascript|2193198|或者，您可以使用更高效、更小的for周期：|2193199|#include+<vector>
#include+<string>
#include+<iostream>

int+main()
{
++++std::vector<std::string>+v{"Hello,+",+"Cruel+",+"World!"};
++++std::string+result;
++++for+(auto+const&+s+:+v)+{+result+%2B=+s;+}
++++std::cout+<<+result;+//+Will+print+"Hello,+Cruel+World!"
}|2193200|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/algorithm/accumulate^0|5|9|H|H|1N|6|1X|A|H|H|0|0|0|F|3|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|F|3|G|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

You could use the <a href="http://en.cppreference.com/w/cpp/algorithm/accumulate" rel="noreferrer"><code>std::accumulate()</code></a> standard function from the <code>&lt;numeric&gt;</code> header (it works because an overload of <code>operator +</code> is defined for <code>string</code>s which returns the concatenation of its two arguments):

<pre><code>#include &lt;vector&gt;
#include &lt;string&gt;
#include &lt;numeric&gt;
#include &lt;iostream&gt;

int main()
{
 std::vector&lt;std::string&gt; v{"Hello, ", " Cruel ", "World!"};
 std::string s;
 s = accumulate(begin(v), end(v), s);
 std::cout &lt;&lt; s; // Will print "Hello, Cruel World!"
}
</code></pre>

Alternatively, you could use a more efficient, small <code>for</code> cycle:

<pre><code>#include &lt;vector&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;

int main()
{
 std::vector&lt;std::string&gt; v{"Hello, ", "Cruel ", "World!"};
 std::string result;
 for (auto const&amp; s : v) { result += s; }
 std::cout &lt;&lt; result; // Will print "Hello, Cruel World!"
}
</code></pre>

blocks|key|858201|text|为什么不直接使用operator+%2B将它们相加呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|858202|std::string+string_from_vector(const+std::vector<std::string>+&pieces)+{
+++return+std::accumulate(pieces.begin(),+pieces.end(),+std::string(""));
}|code-block|syntax|javascript|858203|默认情况下，std::accumulate在幕后使用std::plus，在C%2B%2B中添加两个字符串是连接，因为std::string的运算符%2B是重载的。|858204|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Why not just use operator + to add them together?

<pre><code>std::string string_from_vector(const std::vector&lt;std::string&gt; &amp;pieces) {
 return std::accumulate(pieces.begin(), pieces.end(), std::string(""));
}
</code></pre>

std::accumulate uses std::plus under the hood by default, and adding two strings is concatenation in C++, as the operator + is overloaded for std::string.

blocks|key|5544464|text|有了c%2B%2B11，stringstream方式就不那么可怕了：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|5544465|#include+<vector>
#include+<string>
#include+<algorithm>
#include+<sstream>
#include+<iostream>

int+main()
{
++++std::vector<std::string>+v{"Hello,+",+"+Cruel+",+"World!"};
+++std::stringstream+s;
+++std::for_each(begin(v),+end(v),+[&s](const+std::string+&elem)+{+s+<<+elem;+}+);
+++std::cout+<<+s.str();
}|code-block|syntax|javascript|5544466|entityMap^0|8|C|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

With c++11 the stringstream way is not too scary:

<pre><code>#include &lt;vector&gt;
#include &lt;string&gt;
#include &lt;algorithm&gt;
#include &lt;sstream&gt;
#include &lt;iostream&gt;

int main()
{
 std::vector&lt;std::string&gt; v{"Hello, ", " Cruel ", "World!"};
 std::stringstream s;
 std::for_each(begin(v), end(v), [&amp;s](const std::string &amp;elem) { s &lt;&lt; elem; } );
 std::cout &lt;&lt; s.str();
}
</code></pre>

blocks|key|5544520|text|C%2B%2B03|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5544521|std::string+s;
for+(std::vector<std::string>::const_iterator+i+=+v.begin();+i+!=+v.end();+%2B%2Bi)
++++s+%2B=+*i;
return+s;|code-block|syntax|javascript|5544522|C%2B%2B11+(MSVC2010的子集)|5544523|std::string+s;
std::for_each(v.begin(),+v.end(),+[&](const+std::string+&piece){+s+%2B=+piece;+});
return+s;|5544524|C%2B%2B11|5544525|std::string+s;
for+(const+auto+&piece+:+v)+s+%2B=+piece;
return+s;|5544526|对于字符串连接，请不要使用std::accumulate+，这是一个经典的Schlemiel+the+Painter's+algorithm，甚至比C中使用strcat的常见示例还要糟糕。如果没有C%2B%2B11移动语义，它会为向量的每个元素产生两个不必要的累加器副本。即使使用移动语义，它仍然会为每个元素产生一个不必要的累加器副本。|offset|length|style|BOLD|CODE|5544527|上面的三个例子是O(n)。|5544528|对于字符串，std::accumulate是O(n²)。|5544529|对于字符串，您可以通过提供一个自定义函数器来实现std::accumulate+O(n)：|5544530|std::string+s=+std::accumulate(v.begin()，v.end()，std::string{}，std::string+&s,+const+std::string+&piece+->+decltype(auto)+{+return+s+%2B=+piece；})；|5544531|注意，s必须是对非常数的引用，lambda返回类型必须是引用(因此是decltype(auto))，主体必须使用%2B=而不是%2B。|5544532|5544533|C%2B%2B20|5544534|在预计将成为C%2B%2B20的当前草案中，std::accumulate的定义已经被altered，以便在追加到累加器时使用std::move，因此从C%2B%2B20开始，accumulate将是字符串的O(n)，并且可以用作一行程序：|5544535|std::string+s+=+std::accumulate(v.begin(),+v.end(),+std::string{});|5544536|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Schlemiel_the_Painter%2527s_algorithm|1|std::string+&s,+const+std::string+&piece|2|http://wg21.link/p0616r0^0|0|0|0|0|0|0|D|F|D|F|26|6|11|X|0|0|8|4|0|6|F|M|5|0|O|F|0|1R|14|1|0|3|1|Y|E|1K|2|1P|1|0|0|0|I|F|1N|9|28|A|2O|4|13|7|2|0|0^^$0|@$1|2|3|4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1S|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1T|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1U|8|@$Q|1V|R|1W|S|T]|$Q|1X|R|1Y|S|U]|$Q|1Z|R|20|S|U]]|9|@$Q|21|R|22|1|23]]|A|$]]|$1|V|3|W|5|6|7|24|8|@$Q|25|R|26|S|T]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|27|8|@$Q|28|R|29|S|U]|$Q|2A|R|2B|S|T]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2C|8|@$Q|2D|R|2E|S|U]]|9|@]|A|$]]|$1|11|3|12|5|6|7|2F|8|@]|9|@$Q|2G|R|2H|1|2I]]|A|$]]|$1|13|3|14|5|6|7|2J|8|@$Q|2K|R|2L|S|U]|$Q|2M|R|2N|S|U]|$Q|2O|R|2P|S|U]|$Q|2Q|R|2R|S|U]]|9|@]|A|$]]|$1|15|3|-4|5|6|7|2S|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2T|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2U|8|@$Q|2V|R|2W|S|U]|$Q|2X|R|2Y|S|U]|$Q|2Z|R|30|S|U]|$Q|31|R|32|S|T]]|9|@$Q|33|R|34|1|35]]|A|$]]|$1|1A|3|1B|5|D|7|36|8|@]|9|@]|A|$E|F]]|$1|1C|3|-4|5|6|7|37|8|@]|9|@]|A|$]]]|1D|$1E|$5|1F|1G|1H|A|$1I|1J]]|1K|$5|1F|1G|1H|A|$1I|1L]]|1M|$5|1F|1G|1H|A|$1I|1N]]]]

<h1>C++03</h1>
<pre class="lang-cpp prettyprint-override"><code>std::string s;
for (std::vector&lt;std::string&gt;::const_iterator i = v.begin(); i != v.end(); ++i)
 s += *i;
return s;
</code></pre>
<h1>C++11 (the MSVC 2010 subset)</h1>
<pre class="lang-cpp prettyprint-override"><code>std::string s;
std::for_each(v.begin(), v.end(), [&amp;](const std::string &amp;piece){ s += piece; });
return s;
</code></pre>
<h1>C++11</h1>
<pre class="lang-cpp prettyprint-override"><code>std::string s;
for (const auto &amp;piece : v) s += piece;
return s;
</code></pre>
Don't use <code>std::accumulate</code> for string concatenation, it is a classic <a href="http://en.wikipedia.org/wiki/Schlemiel_the_Painter%27s_algorithm" rel="noreferrer">Schlemiel the Painter's algorithm</a>, even worse than the usual example using <code>strcat</code> in C. Without C++11 move semantics, it incurs two unnecessary copies of the accumulator for each element of the vector. Even with move semantics, it still incurs one unnecessary copy of the accumulator for each element.
The three examples above are O(n).
<code>std::accumulate</code> is O(n²) for strings.
<blockquote>
You could make <code>std::accumulate</code> O(n) for strings by supplying a
custom functor:
<pre><code>std::string s = std::accumulate(v.begin(), v.end(), std::string{},
 [](std::string &amp;s, const std::string &amp;piece) -&gt; decltype(auto) { return s += piece; });
</code></pre>
Note that <code>s</code> must be a reference to non-const, the lambda return type
must be a reference (hence <code>decltype(auto)</code>), and the body must use
<code>+=</code> not <code>+</code>.
</blockquote>
<h1>C++20</h1>
In the current draft of what is expected to become C++20, the definition of <code>std::accumulate</code> has been <a href="http://wg21.link/p0616r0" rel="noreferrer">altered</a> to use <code>std::move</code> when appending to the accumulator, so from C++20 onwards, <code>accumulate</code> will be O(n) for strings, and can be used as a one-liner:
<pre><code>std::string s = std::accumulate(v.begin(), v.end(), std::string{});
</code></pre>

blocks|key|5544552|text|我个人的选择是基于范围的for循环，就像在Oktalist's+answer中一样。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5544553|Boost还提供了一个很好的解决方案：|5544554|#include+<boost/algorithm/string/join.hpp>
#include+<iostream>
#include+<vector>

int+main()+{

++++std::vector<std::string>+v{"first",+"second"};

++++std::string+joined+=+boost::algorithm::join(v,+",+");

++++std::cout+<<+joined+<<+std::endl;
}|code-block|syntax|javascript|5544555|这将打印：|5544556|5544557|+first，second|blockquote|5544558|5544559|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/18703743/341970^0|L|H|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|14|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|15|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]|$1|N|3|O|5|P|7|17|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|C|$]]|$1|R|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]]]

My personal choice would be the range-based for loop, as in <a href="https://stackoverflow.com/a/18703743/341970">Oktalist's answer</a>.
Boost also offers a nice solution:
<pre><code>#include &lt;boost/algorithm/string/join.hpp&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;

int main() {

 std::vector&lt;std::string&gt; v{&quot;first&quot;, &quot;second&quot;};

 std::string joined = boost::algorithm::join(v, &quot;, &quot;);

 std::cout &lt;&lt; joined &lt;&lt; std::endl;
}
</code></pre>
This prints:
<blockquote>
first, second
</blockquote>

blocks|key|2193393|text|有点晚了，但我喜欢我们可以使用初始化器列表的事实：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2193394|std::string+join(std::initializer_list<std::string>+i)
{
++std::vector<std::string>+v(i);
++std::string+res;
++for+(const+auto+&s:+v)+res+%2B=+s;
++return+res;+++
}|code-block|syntax|javascript|2193395|然后，您可以简单地调用(Python样式)：|2193396|join({"Hello",+"World",+"1"})|2193397|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

A little late to the party, but I liked the fact that we can use initializer lists:

<pre><code>std::string join(std::initializer_list&lt;std::string&gt; i)
{
 std::vector&lt;std::string&gt; v(i);
 std::string res;
 for (const auto &amp;s: v) res += s;
 return res; 
}
</code></pre>

Then you can simply invoke (Python style):

<pre><code>join({"Hello", "World", "1"})
</code></pre>

blocks|key|69926|text|Google+Abseil有一个函数absl::StrJoin，它可以做你需要的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|69927|示例来自他们的header文件。请注意，分隔符也可以为""|offset|length|style|CODE|69928|//+++std::vector<std::string>+v+=+{"foo",+"bar",+"baz"};
//+++std::string+s+=+absl::StrJoin(v,+"-");
//+++EXPECT_EQ("foo-bar-baz",+s);|code-block|syntax|javascript|69929|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/abseil/abseil-cpp/blob/04edad3801ec0b1091df9157b879d8f6a50c5036/absl/strings/str_join.h#L40^0|0|R|2|7|6|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|H|3|I|5|J|7|11|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Google Abseil has function absl::StrJoin that does what you need. 

Example from their <a href="https://github.com/abseil/abseil-cpp/blob/04edad3801ec0b1091df9157b879d8f6a50c5036/absl/strings/str_join.h#L40" rel="nofollow noreferrer">header</a> file. 
Notice that separator can be also <code>""</code>

<pre><code>// std::vector&lt;std::string&gt; v = {"foo", "bar", "baz"};
// std::string s = absl::StrJoin(v, "-");
// EXPECT_EQ("foo-bar-baz", s);
</code></pre>

blocks|key|69947|text|如果不需要尾随空格，可以将<numeric>中定义的accumulate与自定义的join+lambda一起使用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|69948|#include+<iostream>
#include+<numeric>
#include+<vector>

using+namespace+std;


int+main()+{
++++vector<string>+v;
++++string+s;

++++v.push_back(string("fee"));
++++v.push_back(string("fi"));
++++v.push_back(string("foe"));
++++v.push_back(string("fum"));

++++s+=+accumulate(begin(v),+end(v),+string(),
+++++++++++++++++++[](string+lhs,+const+string+&rhs)+{+return+lhs.empty()+?+rhs+:+lhs+%2B+'+'+%2B+rhs;+}
++++);
++++cout+<<+s+<<+endl;
++++return+0;
}|code-block|syntax|javascript|69949|输出：|69950|fee+fi+foe+fum|69951|entityMap^0|D|9|Q|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

If requires no trailing spaces, use <code>accumulate</code> defined in <code>&lt;numeric&gt;</code> with custom join lambda.

<pre class="lang-cpp prettyprint-override"><code>#include &lt;iostream&gt;
#include &lt;numeric&gt;
#include &lt;vector&gt;

using namespace std;


int main() {
 vector&lt;string&gt; v;
 string s;

 v.push_back(string("fee"));
 v.push_back(string("fi"));
 v.push_back(string("foe"));
 v.push_back(string("fum"));

 s = accumulate(begin(v), end(v), string(),
 [](string lhs, const string &amp;rhs) { return lhs.empty() ? rhs : lhs + ' ' + rhs; }
 );
 cout &lt;&lt; s &lt;&lt; endl;
 return 0;
}
</code></pre>

Output:

<pre><code>fee fi foe fum
</code></pre>

I'd like to build a <code>std::string</code> from a <code>std::vector&lt;std::string&gt;</code>.

I could use <code>std::stringsteam</code>, but imagine there is a shorter way:

<pre><code>std::string string_from_vector(const std::vector&lt;std::string&gt; &amp;pieces) {
 std::stringstream ss;

 for(std::vector&lt;std::string&gt;::const_iterator itr = pieces.begin();
 itr != pieces.end();
 ++itr) {
 ss &lt;&lt; *itr;
 }

 return ss.str();
}
</code></pre>

How else might I do this?

How to construct a std::string from a std::vector<string>?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想从std::vector<std::string>构建一个std::string。我可以使用std::stringsteam，但想象一下有一种更短的方法：std::string string_from_vector(const std::vector<std::string> &pieces) { std::st...

问如何从std::vector<string>构造std::string？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何从std::vector<string>构造std::string？EN