blocks|key|1601152|text|#include+<sstream>
#include+<string>

std::stringstream+ss;
ss+<<+"Hello,+world,+"+<<+myInt+<<+niceToSeeYouString;
std::string+s+=+ss.str();|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1601153|看看这篇来自Herb+Sutter的本周大师文章：The+String+Formatters+of+Manor+Farm|unstyled|offset|length|1601154|entityMap|0|LINK|mutability|MUTABLE|url|http://www.gotw.ca/publications/mill19.htm^0|0|P|Z|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@$G|S|H|T|1|U]]|A|$]]|$1|I|3|-4|5|F|7|V|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|P]]]]

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

std::stringstream ss;
ss &lt;&lt; "Hello, world, " &lt;&lt; myInt &lt;&lt; niceToSeeYouString;
std::string s = ss.str();
</code></pre>

Take a look at this Guru Of The Week article from Herb Sutter: <a href="http://www.gotw.ca/publications/mill19.htm" rel="noreferrer">The String Formatters of Manor Farm</a>

blocks|key|1601323|text|5年来没有人再提过.append|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1601324|#include+<string>

std::string+s;
s.append("Hello+world,+");
s.append("nice+to+see+you,+");
s.append("or+not.");|code-block|syntax|javascript|1601325|entityMap^0|9|7|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|$]]

In 5 years nobody has mentioned <code>.append</code>?

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

std::string s;
s.append("Hello world, ");
s.append("nice to see you, ");
s.append("or not.");
</code></pre>

blocks|key|1601040|text|s+%2B=+"Hello+world,+"+%2B+"nice+to+see+you,+"+%2B+"or+not.";|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1601041|这些字符数组文字不是C%2B%2B+std::strings您需要将它们转换为：|unstyled|1601042|s+%2B=+string("Hello+world,+")+%2B+string("nice+to+see+you,+")+%2B+string("or+not.");|1601043|要转换int(或任何其他流类型)，您可以使用boost+lexical_cast或提供自己的函数：|1601044|template+<typename+T>
string+Str(+const+T+&+t+)+{
+++ostringstream+os;
+++os+<<+t;
+++return+os.str();
}|1601045|你现在可以说这样的话：|1601046|string+s+=+string("The+meaning+is+")+%2B+Str(+42+);|1601047|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|Q|3|-4|5|F|7|Z|8|@]|9|@]|A|$]]]|R|$]]

<pre><code>s += "Hello world, " + "nice to see you, " + "or not.";
</code></pre>

Those character array literals are not C++ std::strings - you need to convert them:

<pre><code>s += string("Hello world, ") + string("nice to see you, ") + string("or not.");
</code></pre>

To convert ints (or any other streamable type) you can use a boost lexical_cast or provide your own function:

<pre><code>template &lt;typename T&gt;
string Str( const T &amp; t ) {
 ostringstream os;
 os &lt;&lt; t;
 return os.str();
}
</code></pre>

You can now say things like:

<pre><code>string s = string("The meaning is ") + Str( 42 );
</code></pre>

blocks|key|1601266|text|使用C%2B%2B14用户定义的文本和std::to_string，代码会变得更容易。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1601267|using+namespace+std::literals::string_literals;
std::string+str;
str+%2B=+"Hello+World,+"s+%2B+"nice+to+see+you,+"s+%2B+"or+not"s;
str+%2B=+"Hello+World,+"s+%2B+std::to_string(my_int)+%2B+other_string;|code-block|syntax|javascript|1601268|请注意，连接字符串文字可以在编译时完成。只需删除%2B即可。|1601269|str+%2B=+"Hello+World,+"+"nice+to+see+you,+"+"or+not";|1601270|entityMap^0|F|E|0|0|O|1|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|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|$]]

Using C++14 user defined literals and <code>std::to_string</code> the code becomes easier.

<pre><code>using namespace std::literals::string_literals;
std::string str;
str += "Hello World, "s + "nice to see you, "s + "or not"s;
str += "Hello World, "s + std::to_string(my_int) + other_string;
</code></pre>

Note that concatenating string literals can be done at compile time. Just remove the <code>+</code>.

<pre><code>str += "Hello World, " "nice to see you, " "or not";
</code></pre>

blocks|key|1601093|text|boost::format|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1601094|或std::stringstream|1601095|std::stringstream+msg;
msg+<<+"Hello+world,+"+<<+myInt++<<+niceToSeeYouString;
msg.str();+//+returns+std::string+object|code-block|syntax|javascript|1601096|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

boost::format 

or std::stringstream

<pre><code>std::stringstream msg;
msg &lt;&lt; "Hello world, " &lt;&lt; myInt &lt;&lt; niceToSeeYouString;
msg.str(); // returns std::string object
</code></pre>

blocks|key|1386591|text|auto+s+=+string("one").append("two").append("three")|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1386592|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>auto s = string("one").append("two").append("three")
</code></pre>

blocks|key|1601220|text|您必须为您想要连接到字符串的每种数据类型定义operator%2B()，但是由于operator<<是为大多数类型定义的，所以您应该使用std::stringstream。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1601221|可恶，差50秒...|1601222|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You would have to define operator+() for every data type you would want to concenate to the string, yet since operator&lt;&lt; is defined for most types, you should use std::stringstream.

Damn, beat by 50 seconds...

blocks|key|1386424|text|如果您写出%2B=，它看起来几乎与C#一样|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1386425|string+s("Some+initial+data.+");+int+i+=+5;
s+=+s+%2B+"Hello+world,+"+%2B+"nice+to+see+you,+"+%2B+to_string(i)+%2B+"\n";|code-block|syntax|javascript|1386426|entityMap^0|5|2|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|$]]

If you write out the <code>+=</code>, it looks almost the same as C#

<pre><code>string s("Some initial data. "); int i = 5;
s = s + "Hello world, " + "nice to see you, " + to_string(i) + "\n";
</code></pre>

blocks|key|1601418|text|正如其他人所说，操作码的主要问题是操作符%2B没有连接const+char+*；尽管它可以与std::string一起工作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1601419|下面是另一个解决方案，它使用C%2B%2B11、lambda和for_each，并允许提供一个separator来分隔字符串：|1601420|#include+<vector>
#include+<algorithm>
#include+<iterator>
#include+<sstream>

string+join(const+string&+separator,
++++++++++++const+vector<string>&+strings)
{
++++if+(strings.empty())
++++++++return+"";

++++if+(strings.size()+==+1)
++++++++return+strings[0];

++++stringstream+ss;
++++ss+<<+strings[0];

++++auto+aggregate+=+[&ss,+&separator](const+string&+s)+{+ss+<<+separator+<<+s;+};
++++for_each(begin(strings)+%2B+1,+end(strings),+aggregate);

++++return+ss.str();
}|code-block|syntax|javascript|1601421|用法：|1601422|std::vector<std::string>+strings+{+"a",+"b",+"c"+};
std::string+joinedStrings+=+join(",+",+strings);|1601423|它看起来伸缩性很好(线性)，至少在我的计算机上快速测试后是这样的；这是我写的一个快速测试：|1601424|#include+<vector>
#include+<algorithm>
#include+<iostream>
#include+<iterator>
#include+<sstream>
#include+<chrono>

using+namespace+std;

string+join(const+string&+separator,
++++++++++++const+vector<string>&+strings)
{
++++if+(strings.empty())
++++++++return+"";

++++if+(strings.size()+==+1)
++++++++return+strings[0];

++++stringstream+ss;
++++ss+<<+strings[0];

++++auto+aggregate+=+[&ss,+&separator](const+string&+s)+{+ss+<<+separator+<<+s;+};
++++for_each(begin(strings)+%2B+1,+end(strings),+aggregate);

++++return+ss.str();
}

int+main()
{
++++const+int+reps+=+1000;
++++const+string+sep+=+",+";
++++auto+generator+=+[](){return+"abcde";};

++++vector<string>+strings10(10);
++++generate(begin(strings10),+end(strings10),+generator);

++++vector<string>+strings100(100);
++++generate(begin(strings100),+end(strings100),+generator);

++++vector<string>+strings1000(1000);
++++generate(begin(strings1000),+end(strings1000),+generator);

++++vector<string>+strings10000(10000);
++++generate(begin(strings10000),+end(strings10000),+generator);

++++auto+t1+=+chrono::system_clock::now();
++++for(int+i+=+0;+i<reps;+%2B%2Bi)
++++{
++++++++join(sep,+strings10);
++++}

++++auto+t2+=+chrono::system_clock::now();
++++for(int+i+=+0;+i<reps;+%2B%2Bi)
++++{
++++++++join(sep,+strings100);
++++}

++++auto+t3+=+chrono::system_clock::now();
++++for(int+i+=+0;+i<reps;+%2B%2Bi)
++++{
++++++++join(sep,+strings1000);
++++}

++++auto+t4+=+chrono::system_clock::now();
++++for(int+i+=+0;+i<reps;+%2B%2Bi)
++++{
++++++++join(sep,+strings10000);
++++}

++++auto+t5+=+chrono::system_clock::now();

++++auto+d1+=+chrono::duration_cast<chrono::milliseconds>(t2+-+t1);
++++auto+d2+=+chrono::duration_cast<chrono::milliseconds>(t3+-+t2);
++++auto+d3+=+chrono::duration_cast<chrono::milliseconds>(t4+-+t3);
++++auto+d4+=+chrono::duration_cast<chrono::milliseconds>(t5+-+t4);

++++cout+<<+"join(10)+++:+"+<<+d1.count()+<<+endl;
++++cout+<<+"join(100)++:+"+<<+d2.count()+<<+endl;
++++cout+<<+"join(1000)+:+"+<<+d3.count()+<<+endl;
++++cout+<<+"join(10000):+"+<<+d4.count()+<<+endl;
}|1601425|结果(毫秒)：|1601426|join(10)+++:+2
join(100)++:+10
join(1000)+:+91
join(10000):+898|1601427|entityMap^0|K|1|P|C|18|B|0|R|8|17|9|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1F|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1G|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1H|8|@]|D|@]|E|$]]|$1|W|3|X|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|Y|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|Z|$]]

As others said, the main problem with the OP code is that the operator <code>+</code> does not concatenate <code>const char *</code>; it works with <code>std::string</code>, though.

Here's another solution that uses C++11 lambdas and <code>for_each</code> and allows to provide a <code>separator</code> to separate the strings:

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

string join(const string&amp; separator,
 const vector&lt;string&gt;&amp; strings)
{
 if (strings.empty())
 return "";

 if (strings.size() == 1)
 return strings[0];

 stringstream ss;
 ss &lt;&lt; strings[0];

 auto aggregate = [&amp;ss, &amp;separator](const string&amp; s) { ss &lt;&lt; separator &lt;&lt; s; };
 for_each(begin(strings) + 1, end(strings), aggregate);

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

Usage:

<pre><code>std::vector&lt;std::string&gt; strings { "a", "b", "c" };
std::string joinedStrings = join(", ", strings);
</code></pre>

It seems to scale well (linearly), at least after a quick test on my computer; here's a quick test I've written:

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

using namespace std;

string join(const string&amp; separator,
 const vector&lt;string&gt;&amp; strings)
{
 if (strings.empty())
 return "";

 if (strings.size() == 1)
 return strings[0];

 stringstream ss;
 ss &lt;&lt; strings[0];

 auto aggregate = [&amp;ss, &amp;separator](const string&amp; s) { ss &lt;&lt; separator &lt;&lt; s; };
 for_each(begin(strings) + 1, end(strings), aggregate);

 return ss.str();
}

int main()
{
 const int reps = 1000;
 const string sep = ", ";
 auto generator = [](){return "abcde";};

 vector&lt;string&gt; strings10(10);
 generate(begin(strings10), end(strings10), generator);

 vector&lt;string&gt; strings100(100);
 generate(begin(strings100), end(strings100), generator);

 vector&lt;string&gt; strings1000(1000);
 generate(begin(strings1000), end(strings1000), generator);

 vector&lt;string&gt; strings10000(10000);
 generate(begin(strings10000), end(strings10000), generator);

 auto t1 = chrono::system_clock::now();
 for(int i = 0; i&lt;reps; ++i)
 {
 join(sep, strings10);
 }

 auto t2 = chrono::system_clock::now();
 for(int i = 0; i&lt;reps; ++i)
 {
 join(sep, strings100);
 }

 auto t3 = chrono::system_clock::now();
 for(int i = 0; i&lt;reps; ++i)
 {
 join(sep, strings1000);
 }

 auto t4 = chrono::system_clock::now();
 for(int i = 0; i&lt;reps; ++i)
 {
 join(sep, strings10000);
 }

 auto t5 = chrono::system_clock::now();

 auto d1 = chrono::duration_cast&lt;chrono::milliseconds&gt;(t2 - t1);
 auto d2 = chrono::duration_cast&lt;chrono::milliseconds&gt;(t3 - t2);
 auto d3 = chrono::duration_cast&lt;chrono::milliseconds&gt;(t4 - t3);
 auto d4 = chrono::duration_cast&lt;chrono::milliseconds&gt;(t5 - t4);

 cout &lt;&lt; "join(10) : " &lt;&lt; d1.count() &lt;&lt; endl;
 cout &lt;&lt; "join(100) : " &lt;&lt; d2.count() &lt;&lt; endl;
 cout &lt;&lt; "join(1000) : " &lt;&lt; d3.count() &lt;&lt; endl;
 cout &lt;&lt; "join(10000): " &lt;&lt; d4.count() &lt;&lt; endl;
}
</code></pre>

Results (milliseconds):

<pre><code>join(10) : 2
join(100) : 10
join(1000) : 91
join(10000): 898
</code></pre>

blocks|key|1601503|text|也许你喜欢我的"Streamer“解决方案，让它真正做到这一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1601504|#include+<iostream>
#include+<sstream>
using+namespace+std;

class+Streamer+//+class+for+one+line+string+generation
{
public:

++++Streamer&+clear()+//+clear+content
++++{
++++++++ss.str("");+//+set+to+empty+string
++++++++ss.clear();+//+clear+error+flags
++++++++return+*this;
++++}

++++template+<typename+T>
++++friend+Streamer&+operator<<(Streamer&+streamer,T+str);+//+add+to+streamer

++++string+str()+//+get+current+string
++++{+return+ss.str();}

private:
++++stringstream+ss;
};

template+<typename+T>
Streamer&+operator<<(Streamer&+streamer,T+str)
{+streamer.ss<<str;return+streamer;}

Streamer+streamer;+//+make+this+a+global+variable


class+MyTestClass+//+just+a+test+class
{
public:
++++MyTestClass()+:+data(0.12345){}
++++friend+ostream&+operator<<(ostream&+os,const+MyTestClass&+myClass);
private:
++++double+data;
};

ostream&+operator<<(ostream&+os,const+MyTestClass&+myClass)+//+print+test+class
{+return+os<<myClass.data;}


int+main()
{
++++int+i=0;
++++string+s1=(streamer.clear()<<"foo"<<"bar"<<"test").str();++++++++++++++++++++++//+test+strings
++++string+s2=(streamer.clear()<<"i:"<<i%2B%2B<<"+"<<i%2B%2B<<"+"<<i%2B%2B<<"+"<<0.666).str();+//+test+numbers
++++string+s3=(streamer.clear()<<"test+class:"<<MyTestClass()).str();++++++++++++++//+test+with+test+class
++++cout<<"s1:+'"<<s1<<"'"<<endl;
++++cout<<"s2:+'"<<s2<<"'"<<endl;
++++cout<<"s3:+'"<<s3<<"'"<<endl;
}|code-block|syntax|javascript|1601505|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Maybe you like my "Streamer" solution to really do it in one line:

<pre><code>#include &lt;iostream&gt;
#include &lt;sstream&gt;
using namespace std;

class Streamer // class for one line string generation
{
public:

 Streamer&amp; clear() // clear content
 {
 ss.str(""); // set to empty string
 ss.clear(); // clear error flags
 return *this;
 }

 template &lt;typename T&gt;
 friend Streamer&amp; operator&lt;&lt;(Streamer&amp; streamer,T str); // add to streamer

 string str() // get current string
 { return ss.str();}

private:
 stringstream ss;
};

template &lt;typename T&gt;
Streamer&amp; operator&lt;&lt;(Streamer&amp; streamer,T str)
{ streamer.ss&lt;&lt;str;return streamer;}

Streamer streamer; // make this a global variable


class MyTestClass // just a test class
{
public:
 MyTestClass() : data(0.12345){}
 friend ostream&amp; operator&lt;&lt;(ostream&amp; os,const MyTestClass&amp; myClass);
private:
 double data;
};

ostream&amp; operator&lt;&lt;(ostream&amp; os,const MyTestClass&amp; myClass) // print test class
{ return os&lt;&lt;myClass.data;}


int main()
{
 int i=0;
 string s1=(streamer.clear()&lt;&lt;"foo"&lt;&lt;"bar"&lt;&lt;"test").str(); // test strings
 string s2=(streamer.clear()&lt;&lt;"i:"&lt;&lt;i++&lt;&lt;" "&lt;&lt;i++&lt;&lt;" "&lt;&lt;i++&lt;&lt;" "&lt;&lt;0.666).str(); // test numbers
 string s3=(streamer.clear()&lt;&lt;"test class:"&lt;&lt;MyTestClass()).str(); // test with test class
 cout&lt;&lt;"s1: '"&lt;&lt;s1&lt;&lt;"'"&lt;&lt;endl;
 cout&lt;&lt;"s2: '"&lt;&lt;s2&lt;&lt;"'"&lt;&lt;endl;
 cout&lt;&lt;"s3: '"&lt;&lt;s3&lt;&lt;"'"&lt;&lt;endl;
}
</code></pre>

blocks|key|1386372|text|您可以在这方面使用此标头：https://github.com/theypsilon/concat|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1386373|using+namespace+concat;

assert(concat(1,2,3,4,5)+==+"12345");|code-block|syntax|javascript|1386374|在幕后，您将使用std::ostringstream。|1386375|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/theypsilon/concat^0|D|10|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

You may use this header for this regard: <a href="https://github.com/theypsilon/concat" rel="nofollow">https://github.com/theypsilon/concat</a>

<pre><code>using namespace concat;

assert(concat(1,2,3,4,5) == "12345");
</code></pre>

Under the hood you will be using a std::ostringstream.

blocks|key|1601395|text|如果您愿意使用c%2B%2B11，您可以利用user-defined+string+literals并定义两个函数模板，这两个函数模板重载std::string对象和任何其他对象的加号运算符。唯一的缺陷是不要重载std::string的加号运算符，否则编译器不知道使用哪个运算符。您可以使用type_traits中的模板std::enable_if来完成此操作。在那之后，字符串的行为就像Java或C#中的那样。有关详细信息，请参阅我的示例实现。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1601396|主代码|1601397|#include+<iostream>
#include+"c_sharp_strings.hpp"

using+namespace+std;

int+main()
{
++++int+i+=+0;
++++float+f+=+0.4;
++++double+d+=+1.3e-2;
++++string+s;
++++s+%2B=+"Hello+world,+"_+%2B+"nice+to+see+you.+"_+%2B+i
++++++++++++%2B+"+"_+%2B+47+%2B+"+"_+%2B+f+%2B+','+%2B+d;
++++cout+<<+s+<<+endl;
++++return+0;
}|code-block|syntax|javascript|1601398|文件c_sharp_strings.hpp|1601399|在您想要拥有这些字符串的所有位置中都包含这个头文件。|1601400|#ifndef+C_SHARP_STRING_H_INCLUDED
#define+C_SHARP_STRING_H_INCLUDED

#include+<type_traits>
#include+<string>

inline+std::string+operator+""+_(const+char+a[],+long+unsigned+int+i)
{
++++return+std::string(a);
}

template<typename+T>+inline
typename+std::enable_if<!std::is_same<std::string,+T>::value+&&
++++++++++++++++++++++++!std::is_same<char,+T>::value+&&
++++++++++++++++++++++++!std::is_same<const+char*,+T>::value,+std::string>::type
operator%2B+(std::string+s,+T+i)
{
++++return+s+%2B+std::to_string(i);
}

template<typename+T>+inline
typename+std::enable_if<!std::is_same<std::string,+T>::value+&&
++++++++++++++++++++++++!std::is_same<char,+T>::value+&&
++++++++++++++++++++++++!std::is_same<const+char*,+T>::value,+std::string>::type
operator%2B+(T+i,+std::string+s)
{
++++return+std::to_string(i)+%2B+s;
}

#endif+//+C_SHARP_STRING_H_INCLUDED|1601401|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/language/user_literal|1|http://en.cppreference.com/w/cpp/header/type_traits|2|http://en.cppreference.com/w/cpp/types/enable_if^0|7|5|1T|B|2U|B|3X|B|4C|E|I|S|0|3X|B|1|4C|E|2|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@$9|1F|A|1G|1|1H]|$9|1I|A|1J|1|1K]|$9|1L|A|1M|1|1N]]|E|$]]|$1|F|3|G|5|6|7|1O|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1P|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1R|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1S|8|@]|D|@]|E|$K|L]]|$1|S|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]|12|$5|V|W|X|E|$Y|13]]]]

If you are willing to use <code>c++11</code> you can utilize <a href="http://en.cppreference.com/w/cpp/language/user_literal" rel="nofollow">user-defined string literals</a> and define two function templates that overload the plus operator for a <code>std::string</code> object and any other object. The only pitfall is not to overload the plus operators of <code>std::string</code>, otherwise the compiler doesn't know which operator to use. You can do this by using the template <a href="http://en.cppreference.com/w/cpp/types/enable_if" rel="nofollow"><code>std::enable_if</code></a> from <a href="http://en.cppreference.com/w/cpp/header/type_traits" rel="nofollow"><code>type_traits</code></a>. After that strings behave just like in Java or C#. See my example implementation for details.

<h1>Main code</h1>

<pre><code>#include &lt;iostream&gt;
#include "c_sharp_strings.hpp"

using namespace std;

int main()
{
 int i = 0;
 float f = 0.4;
 double d = 1.3e-2;
 string s;
 s += "Hello world, "_ + "nice to see you. "_ + i
 + " "_ + 47 + " "_ + f + ',' + d;
 cout &lt;&lt; s &lt;&lt; endl;
 return 0;
}
</code></pre>

<h1>File c_sharp_strings.hpp</h1>

Include this header file in all all places where you want to have these strings.

<pre><code>#ifndef C_SHARP_STRING_H_INCLUDED
#define C_SHARP_STRING_H_INCLUDED

#include &lt;type_traits&gt;
#include &lt;string&gt;

inline std::string operator "" _(const char a[], long unsigned int i)
{
 return std::string(a);
}

template&lt;typename T&gt; inline
typename std::enable_if&lt;!std::is_same&lt;std::string, T&gt;::value &amp;&amp;
 !std::is_same&lt;char, T&gt;::value &amp;&amp;
 !std::is_same&lt;const char*, T&gt;::value, std::string&gt;::type
operator+ (std::string s, T i)
{
 return s + std::to_string(i);
}

template&lt;typename T&gt; inline
typename std::enable_if&lt;!std::is_same&lt;std::string, T&gt;::value &amp;&amp;
 !std::is_same&lt;char, T&gt;::value &amp;&amp;
 !std::is_same&lt;const char*, T&gt;::value, std::string&gt;::type
operator+ (T i, std::string s)
{
 return std::to_string(i) + s;
}

#endif // C_SHARP_STRING_H_INCLUDED
</code></pre>

blocks|key|1386626|text|像这样的东西对我来说很有效|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1386627|namespace+detail+{
++++void+concat_impl(std::ostream&)+{+/*+do+nothing+*/+}

++++template<typename+T,+typename+...Args>
++++void+concat_impl(std::ostream&+os,+const+T&+t,+Args&&...+args)
++++{
++++++++os+<<+t;
++++++++concat_impl(os,+std::forward<Args>(args)...);
++++}
}+/*+namespace+detail+*/

template<typename+...Args>
std::string+concat(Args&&...+args)
{
++++std::ostringstream+os;
++++detail::concat_impl(os,+std::forward<Args>(args)...);
++++return+os.str();
}
//+...
std::string+s{"Hello+World,+"};
s+=+concat(s,+myInt,+niceToSeeYouString,+myChar,+myFoo);|code-block|syntax|javascript|1386628|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Something like this works for me

<pre><code>namespace detail {
 void concat_impl(std::ostream&amp;) { /* do nothing */ }

 template&lt;typename T, typename ...Args&gt;
 void concat_impl(std::ostream&amp; os, const T&amp; t, Args&amp;&amp;... args)
 {
 os &lt;&lt; t;
 concat_impl(os, std::forward&lt;Args&gt;(args)...);
 }
} /* namespace detail */

template&lt;typename ...Args&gt;
std::string concat(Args&amp;&amp;... args)
{
 std::ostringstream os;
 detail::concat_impl(os, std::forward&lt;Args&gt;(args)...);
 return os.str();
}
// ...
std::string s{"Hello World, "};
s = concat(s, myInt, niceToSeeYouString, myChar, myFoo);
</code></pre>

blocks|key|1601568|text|基于上面的解决方案，我为我的项目做了一个var_string类，以使生活变得简单。示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1601569|var_string+x("abc+%25d+%25s",+123,+"def");
std::string+y+=+(std::string)x;
const+char+*z+=+x.c_str();|code-block|syntax|javascript|1601570|类本身：|1601571|#include+<stdlib.h>
#include+<stdarg.h>

class+var_string
{
public:
++++var_string(const+char+*cmd,+...)
++++{
++++++++va_list+args;
++++++++va_start(args,+cmd);
++++++++vsnprintf(buffer,+sizeof(buffer)+-+1,+cmd,+args);
++++}

++++~var_string()+{}

++++operator+std::string()
++++{
++++++++return+std::string(buffer);
++++}

++++operator+char*()
++++{
++++++++return+buffer;
++++}

++++const+char+*c_str()
++++{
++++++++return+buffer;
++++}

++++int+system()
++++{
++++++++return+::system(buffer);
++++}
private:
++++char+buffer[4096];
};|1601572|还在想C%2B%2B中会不会有更好的东西？|1601573|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Based on above solutions I made a class var_string for my project to make life easy. Examples:

<pre><code>var_string x("abc %d %s", 123, "def");
std::string y = (std::string)x;
const char *z = x.c_str();
</code></pre>

The class itself:

<pre><code>#include &lt;stdlib.h&gt;
#include &lt;stdarg.h&gt;

class var_string
{
public:
 var_string(const char *cmd, ...)
 {
 va_list args;
 va_start(args, cmd);
 vsnprintf(buffer, sizeof(buffer) - 1, cmd, args);
 }

 ~var_string() {}

 operator std::string()
 {
 return std::string(buffer);
 }

 operator char*()
 {
 return buffer;
 }

 const char *c_str()
 {
 return buffer;
 }

 int system()
 {
 return ::system(buffer);
 }
private:
 char buffer[4096];
};
</code></pre>

Still wondering if there will be something better in C++ ?

blocks|key|1601600|text|在c11中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1601601|void+printMessage(std::string&&+message)+{
++++std::cout+<<+message+<<+std::endl;
++++return+message;
}|code-block|syntax|javascript|1601602|这使您可以像这样创建函数调用：|1601603|printMessage("message+number+:+"+%2B+std::to_string(id));|1601604|将打印:消息编号:+10|1601605|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

In c11:

<pre><code>void printMessage(std::string&amp;&amp; message) {
 std::cout &lt;&lt; message &lt;&lt; std::endl;
 return message;
}
</code></pre>

this allow you to create function call like this:

<pre><code>printMessage("message number : " + std::to_string(id));
</code></pre>

will print : message number : 10

blocks|key|1601480|text|您还可以“扩展”字符串类并选择您喜欢的运算符(+<<、&、%7C等...)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1601481|下面是使用operator<<显示与流没有冲突的代码|1601482|注意:如果你取消s1.save(30)的注释，只有3个new()运算符请求(1个用于s1，1个用于s2，1个用于保留；不幸的是，您不能在构造函数时保留)；如果没有保留，s1必须随着它的增长请求更多的内存，所以它取决于您的编译器实现增长因子(在这个例子中，我的似乎是1.5，5个new()调用)|1601483|namespace+perso+{
class+string:public+std::string+{
public:
++++string():+std::string(){}

++++template<typename+T>
++++string(const+T+v):+std::string(v)+{}

++++template<typename+T>
++++string&+operator<<(const+T+s){
++++++++*this%2B=s;
++++++++return+*this;
++++}
};
}

using+namespace+std;

int+main()
{
++++using+string+=+perso::string;
++++string+s1,+s2="she";
++++//s1.reserve(30);
++++s1+<<+"no+"+<<+"sunshine+when+"+<<+s2+<<+'\''+<<+'s'+<<+"+gone";
++++cout+<<+"Aint't+"<<+s1+<<+"+..."+<<++endl;

++++return+0;
}|code-block|syntax|javascript|1601484|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

you can also "extend" the string class and choose the operator you prefer ( &lt;&lt;, &amp;, |, etc ...)

Here is the code using operator&lt;&lt; to show there is no conflict with streams

note: if you uncomment s1.reserve(30), there is only 3 new() operator requests (1 for s1, 1 for s2, 1 for reserve ; you can't reserve at constructor time unfortunately); without reserve, s1 has to request more memory as it grows, so it depends on your compiler implementation grow factor (mine seems to be 1.5, 5 new() calls in this example)

<pre><code>namespace perso {
class string:public std::string {
public:
 string(): std::string(){}

 template&lt;typename T&gt;
 string(const T v): std::string(v) {}

 template&lt;typename T&gt;
 string&amp; operator&lt;&lt;(const T s){
 *this+=s;
 return *this;
 }
};
}

using namespace std;

int main()
{
 using string = perso::string;
 string s1, s2="she";
 //s1.reserve(30);
 s1 &lt;&lt; "no " &lt;&lt; "sunshine when " &lt;&lt; s2 &lt;&lt; '\'' &lt;&lt; 's' &lt;&lt; " gone";
 cout &lt;&lt; "Aint't "&lt;&lt; s1 &lt;&lt; " ..." &lt;&lt; endl;

 return 0;
}
</code></pre>

blocks|key|1386845|text|Stringstream带有一个简单的预处理器宏，使用lambda函数，看起来很不错：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1386846|#include+<sstream>
#define+make_string(args)+[]{std::stringstream+ss;+ss+<<+args;+return+ss;}()+|code-block|syntax|javascript|1386847|然后|1386848|auto+str+=+make_string("hello"+<<+"+there"+<<+10+<<+'$');|1386849|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|$]]

Stringstream with a simple preproccessor macro using a lambda function seems nice:

<pre><code>#include &lt;sstream&gt;
#define make_string(args) []{std::stringstream ss; ss &lt;&lt; args; return ss;}() 
</code></pre>

and then

<pre><code>auto str = make_string("hello" &lt;&lt; " there" &lt;&lt; 10 &lt;&lt; '$');
</code></pre>

blocks|key|1601236|text|这对我来说很有效：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1601237|#include+<iostream>

using+namespace+std;

#define+CONCAT2(a,b)+++++string(a)%2Bstring(b)
#define+CONCAT3(a,b,c)+++string(a)%2Bstring(b)%2Bstring(c)
#define+CONCAT4(a,b,c,d)+string(a)%2Bstring(b)%2Bstring(c)%2Bstring(d)

#define+HOMEDIR+"c:\\example"

int+main()
{

++++const+char*+filename+=+"myfile";

++++string+path+=+CONCAT4(HOMEDIR,"\\",filename,".txt");

++++cout+<<+path;
++++return+0;
}|code-block|syntax|javascript|1601238|输出：|1601239|c:\example\myfile.txt|1601240|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|$]]

This works for me:

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

using namespace std;

#define CONCAT2(a,b) string(a)+string(b)
#define CONCAT3(a,b,c) string(a)+string(b)+string(c)
#define CONCAT4(a,b,c,d) string(a)+string(b)+string(c)+string(d)

#define HOMEDIR "c:\\example"

int main()
{

 const char* filename = "myfile";

 string path = CONCAT4(HOMEDIR,"\\",filename,".txt");

 cout &lt;&lt; path;
 return 0;
}
</code></pre>

Output:

<pre><code>c:\example\myfile.txt
</code></pre>

blocks|key|1601639|text|你有没有试过避开%2B=？改为使用var+=+var+%2B+...这对我很管用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1601640|#include+<iostream.h>+//+for+string

string+myName+=+"";
int+_age+=+30;
myName+=+myName+%2B+"Vincent"+%2B+"Thorpe"+%2B+30+%2B+"+"+%2B+2019;|code-block|syntax|javascript|1601641|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Have you tried to avoid the +=?
instead use var = var + ...
it worked for me.

<pre><code>#include &lt;iostream.h&gt; // for string

string myName = "";
int _age = 30;
myName = myName + "Vincent" + "Thorpe" + 30 + " " + 2019;
</code></pre>

C# has a syntax feature where you can concatenate many data types together on 1 line.

<pre><code>string s = new String();
s += "Hello world, " + myInt + niceToSeeYouString;
s += someChar1 + interestingDecimal + someChar2;
</code></pre>

What would be the equivalent in C++? As far as I can see, you'd have to do it all on separate lines as it doesn't support multiple strings/variables with the + operator. This is OK, but doesn't look as neat.

<pre><code>string s;
s += "Hello world, " + "nice to see you, " + "or not.";
</code></pre>

The above code produces an error.

How do I concatenate multiple C++ strings on one line?

编译器

Java

C#有一个语法特性，您可以在一行中将许多数据类型连接在一起。string s = new String();s += "Hello world, " + myInt + niceToSeeYouString;s += someChar1 + interestingDecimal + someChar2;C++中的等价物是什么？据我所知，您必须在单独的行中完成所有这些操作，因为它不支持带有+运算符的

问如何在一行中连接多个C++字符串？
EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在一行中连接多个C++字符串？EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在一行中连接多个C++字符串？
EN