blocks|key|507505|text|std::string不包含这样的函数，但您可以在algorithm头中使用独立的replace函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|507506|#include+<algorithm>
#include+<string>

void+some_func()+{
++std::string+s+=+"example+string";
++std::replace(+s.begin(),+s.end(),+'x',+'y');+//+replace+all+'x'+to+'y'
}|code-block|syntax|javascript|507507|entityMap^0|0|B|P|9|15|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

<code>std::string</code> doesn't contain such function but you could use stand-alone <code>replace</code> function from <code>algorithm</code> header.

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

void some_func() {
 std::string s = "example string";
 std::replace( s.begin(), s.end(), 'x', 'y'); // replace all 'x' to 'y'
}
</code></pre>

blocks|key|3384829|text|正如Kirill建议的那样，要么使用replace方法，要么沿着字符串迭代，分别替换每个字符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3384830|或者，您可以根据需要使用find方法或find_first_of。这些解决方案都不会一下子完成这项工作，但是通过几行额外的代码，您应该让它们为您工作。:-)|offset|length|style|CODE|3384831|entityMap^0|0|C|4|J|D|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

As Kirill suggested, either use the replace method or iterate along the string replacing each char independently. 

Alternatively you can use the <code>find</code> method or <code>find_first_of</code> depending on what you need to do. None of these solutions will do the job in one go, but with a few extra lines of code you ought to make them work for you. :-)

blocks|key|505978|text|一个简单的查找和替换单个字符应该是这样的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|505979|s.replace(s.find("x"),+1,+"y")|offset|length|style|CODE|505980|要对整个字符串执行此操作，最简单的方法是循环，直到s.find开始返回npos。我想你也可以抓住range_error来退出循环，但这有点丑陋。|505981|entityMap^0|0|0|U|0|P|6|Z|4|1C|B|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|K|$]]

A simple find and replace for a single character would go something like:

<code>s.replace(s.find("x"), 1, "y")</code>

To do this for the whole string, the easy thing to do would be to loop until your <code>s.find</code> starts returning <code>npos</code>. I suppose you could also catch <code>range_error</code> to exit the loop, but that's kinda ugly.

blocks|key|505998|text|我想我也应该把boost+solution也扔进去：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|505999|#include+<boost/algorithm/string/replace.hpp>

//+in+place
std::string+in_place+=+"blah#blah";
boost::replace_all(in_place,+"#",+"@");

//+copy
const+std::string+input+=+"blah#blah";
std::string+output+=+boost::replace_all_copy(input,+"#",+"@");|code-block|syntax|javascript|506000|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/release/libs/algorithm/string^0|7|E|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

I thought I'd toss in the <a href="http://www.boost.org/doc/libs/release/libs/algorithm/string">boost solution</a> as well:

<pre><code>#include &lt;boost/algorithm/string/replace.hpp&gt;

// in place
std::string in_place = "blah#blah";
boost::replace_all(in_place, "#", "@");

// copy
const std::string input = "blah#blah";
std::string output = boost::replace_all_copy(input, "#", "@");
</code></pre>

blocks|key|507615|text|这个问题集中在character替换上，但是，由于我发现这个页面非常有用(特别是Konrad的评论)，我想分享这个更通用的实现，它也允许处理substrings：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|507616|std::string+ReplaceAll(std::string+str,+const+std::string&+from,+const+std::string&+to)+{
++++size_t+start_pos+=+0;
++++while((start_pos+=+str.find(from,+start_pos))+!=+std::string::npos)+{
++++++++str.replace(start_pos,+from.length(),+to);
++++++++start_pos+%2B=+to.length();+//+Handles+case+where+'to'+is+a+substring+of+'from'
++++}
++++return+str;
}|code-block|syntax|javascript|507617|用法：|507618|std::cout+<<+ReplaceAll(string("Number+Of+Beans"),+std::string("+"),+std::string("_"))+<<+std::endl;
std::cout+<<+ReplaceAll(string("ghghjghugtghty"),+std::string("gh"),+std::string("X"))+<<+std::endl;
std::cout+<<+ReplaceAll(string("ghghjghugtghty"),+std::string("gh"),+std::string("h"))+<<+std::endl;|507619|输出：|507620|507621|+Number_Of_Beans|blockquote|507622|507623|XXjXugtXty|507624|hhjhugthty|507625|507626|507627|编辑：|BOLD|507628|在您关心性能的情况下，可以以更合适的方式实现上述功能，方法是不返回任何值，并直接对作为参数给定的字符串str执行更改，该字符串通过地址传递，而不是通过值__传递。这将避免对原始字符串进行无用且代价高昂的复制，同时返回结果。你说了算，然后..。|507629|代码：|507630|static+inline+void+ReplaceAll2(std::string+&str,+const+std::string&+from,+const+std::string&+to)
{
++++//+Same+inner+code...
++++//+No+return+statement
}|507631|507632|希望这能对其他人有所帮助。|507633|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/18664/konrad^0|7|9|1Y|A|14|6|0|0|0|0|0|0|0|0|0|0|0|0|0|0|3|0|1F|3|1X|1G|0|0|3|0|0|0|0|D|0^^$0|@$1|2|3|4|5|6|7|1L|8|@$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]]|D|@$9|1Q|A|1R|1|1S]]|E|$]]|$1|F|3|G|5|H|7|1T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1V|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1W|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]|$1|R|3|S|5|T|7|1Y|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|20|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|21|8|@]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|22|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|23|8|@]|D|@]|E|$]]|$1|11|3|12|5|6|7|24|8|@$9|25|A|26|B|13]]|D|@]|E|$]]|$1|14|3|15|5|6|7|27|8|@$9|28|A|29|B|C]|$9|2A|A|2B|B|13]]|D|@]|E|$]]|$1|16|3|17|5|6|7|2C|8|@$9|2D|A|2E|B|13]]|D|@]|E|$]]|$1|18|3|19|5|H|7|2F|8|@]|D|@]|E|$I|J]]|$1|1A|3|-4|5|6|7|2G|8|@]|D|@]|E|$]]|$1|1B|3|1C|5|6|7|2H|8|@$9|2I|A|2J|B|13]]|D|@]|E|$]]|$1|1D|3|-4|5|6|7|2K|8|@]|D|@]|E|$]]]|1E|$1F|$5|1G|1H|1I|E|$1J|1K]]]]

The question is centered on <code>character</code> replacement, but, as I found this page very useful (especially <a href="https://stackoverflow.com/users/18664/konrad">Konrad</a>'s remark), I'd like to share this more generalized implementation, which allows to deal with <code>substrings</code> as well:
<pre><code>std::string ReplaceAll(std::string str, const std::string&amp; from, const std::string&amp; to) {
 size_t start_pos = 0;
 while((start_pos = str.find(from, start_pos)) != std::string::npos) {
 str.replace(start_pos, from.length(), to);
 start_pos += to.length(); // Handles case where 'to' is a substring of 'from'
 }
 return str;
}
</code></pre>
Usage:
<pre><code>std::cout &lt;&lt; ReplaceAll(string(&quot;Number Of Beans&quot;), std::string(&quot; &quot;), std::string(&quot;_&quot;)) &lt;&lt; std::endl;
std::cout &lt;&lt; ReplaceAll(string(&quot;ghghjghugtghty&quot;), std::string(&quot;gh&quot;), std::string(&quot;X&quot;)) &lt;&lt; std::endl;
std::cout &lt;&lt; ReplaceAll(string(&quot;ghghjghugtghty&quot;), std::string(&quot;gh&quot;), std::string(&quot;h&quot;)) &lt;&lt; std::endl;
</code></pre>
Outputs:
<blockquote>
Number_Of_Beans
XXjXugtXty
hhjhugthty
</blockquote>
<hr />
EDIT:
The above can be implemented in a more suitable way, in case performances are of your concern, by returning nothing (<code>void</code>) and performing the changes directly on the string <code>str</code> given as argument, passed by address instead of by value. This would avoid useless and costly copy of the original string, while returning the result. Your call, then...
Code :
<pre><code>static inline void ReplaceAll2(std::string &amp;str, const std::string&amp; from, const std::string&amp; to)
{
 // Same inner code...
 // No return statement
}
</code></pre>
<hr />
Hope this will be helpful for some others...

blocks|key|507635|text|#include+<iostream>
#include+<string>
using+namespace+std;
//+Replace+function..
string+replace(string+word,+string+target,+string+replacement){
++++int+len,+loop=0;
++++string+nword="",+let;
++++len=word.length();
++++len--;
++++while(loop<=len){
++++++++let=word.substr(loop,+1);
++++++++if(let==target){
++++++++++++nword=nword%2Breplacement;
++++++++}else{
++++++++++++nword=nword%2Blet;
++++++++}
++++++++loop%2B%2B;
++++}
++++return+nword;

}
//Main..
int+main()+{
++string+word;
++cout<<"Enter+Word:+";
++cin>>word;
++cout<<replace(word,+"x",+"y")<<endl;
++return+0;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|507636|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>#include &lt;iostream&gt;
#include &lt;string&gt;
using namespace std;
// Replace function..
string replace(string word, string target, string replacement){
 int len, loop=0;
 string nword="", let;
 len=word.length();
 len--;
 while(loop&lt;=len){
 let=word.substr(loop, 1);
 if(let==target){
 nword=nword+replacement;
 }else{
 nword=nword+let;
 }
 loop++;
 }
 return nword;

}
//Main..
int main() {
 string word;
 cout&lt;&lt;"Enter Word: ";
 cin&gt;&gt;word;
 cout&lt;&lt;replace(word, "x", "y")&lt;&lt;endl;
 return 0;
}
</code></pre>

blocks|key|3385026|text|设想一个大的二进制blob，其中所有0x00字节都应该替换为"\1\x30“，所有0x01字节都应该替换为"\1\x31”，因为传输协议不允许使用\0字节。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3385027|在以下情况下：|3385028|替换字符串和要替换的字符串的长度不同，|3385029|要替换的字符串在源字符串中出现的次数很多，|unordered-list-item|3385030|
|3385031|源字符串很大，|3385032|3385033|所提供的解决方案无法应用(因为它们只替换单个字符)或存在性能问题，因为它们会多次调用string::replace，从而一遍又一遍地生成blob大小的副本。(我不知道boost解决方案，也许从这个角度来说还可以)|3385034|它遍历源字符串中的所有匹配项，并一次一次地逐段构建新字符串|3385035|void+replaceAll(std::string&+source,+const+std::string&+from,+const+std::string&+to)
{
++++std::string+newString;
++++newString.reserve(source.length());++//+avoids+a+few+memory+allocations

++++std::string::size_type+lastPos+=+0;
++++std::string::size_type+findPos;

++++while(std::string::npos+!=+(findPos+=+source.find(from,+lastPos)))
++++{
++++++++newString.append(source,+lastPos,+findPos+-+lastPos);
++++++++newString+%2B=+to;
++++++++lastPos+=+findPos+%2B+from.length();
++++}

++++//+Care+for+the+rest+after+last+occurrence
++++newString+%2B=+source.substr(lastPos);

++++source.swap(newString);
}|code-block|syntax|javascript|3385036|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|12|8|@]|9|@]|A|$]]|$1|K|3|L|5|H|7|13|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|15|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|16|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|17|8|@]|9|@]|A|$U|V]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

Imagine a large binary blob where all 0x00 bytes shall be replaced by "\1\x30" and all 0x01 bytes by "\1\x31" because the transport protocol allows no \0-bytes.

In cases where:

<ul>
<li>the replacing and the to-replaced string have different lengths,</li>
<li>there are many occurences of the to-replaced string within the source string and</li>
<li>the source string is large,</li>
</ul>

the provided solutions cannot be applied (because they replace only single characters) or have a performance problem, because they would call string::replace several times which generates copies of the size of the blob over and over.
(I do not know the boost solution, maybe it is OK from that perspective)

This one walks along all occurrences in the source string and builds the new string piece by piece once:

<pre><code>void replaceAll(std::string&amp; source, const std::string&amp; from, const std::string&amp; to)
{
 std::string newString;
 newString.reserve(source.length()); // avoids a few memory allocations

 std::string::size_type lastPos = 0;
 std::string::size_type findPos;

 while(std::string::npos != (findPos = source.find(from, lastPos)))
 {
 newString.append(source, lastPos, findPos - lastPos);
 newString += to;
 lastPos = findPos + from.length();
 }

 // Care for the rest after last occurrence
 newString += source.substr(lastPos);

 source.swap(newString);
}
</code></pre>

blocks|key|1254417|text|如果您希望替换多个字符，并且只处理std::string，那么这个代码片段将会起作用，将sHaystack中的sNeedle替换为sReplace，并且sNeedle和sReplace不需要大小相同。此例程使用while循环替换所有匹配项，而不仅仅是从左到右找到的第一个匹配项。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1254418|while(sHaystack.find(sNeedle)+!=+std::string::npos)+{
++sHaystack.replace(sHaystack.find(sNeedle),sNeedle.size(),sReplace);
}|code-block|syntax|javascript|1254419|entityMap^0|H|B|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're looking to replace more than a single character, and are dealing only with <code>std::string</code>, then this snippet would work, replacing sNeedle in sHaystack with sReplace, and sNeedle and sReplace do not need to be the same size. This routine uses the while loop to replace all occurrences, rather than just the first one found from left to right.

<pre class="lang-cpp prettyprint-override"><code>while(sHaystack.find(sNeedle) != std::string::npos) {
 sHaystack.replace(sHaystack.find(sNeedle),sNeedle.size(),sReplace);
}
</code></pre>

blocks|key|1977269|text|这行得通！我在一个书店应用程序中使用了类似的东西，其中库存存储在CSV中(类似于.dat文件)。但是在单个字符的情况下，这意味着替换器只是一个字符，例如‘%7C’，它必须用双引号"%7C“括起来，这样才不会抛出无效的转换常量字符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1977270|#include+<iostream>
#include+<string>

using+namespace+std;

int+main()
{
++++int+count+=+0;++//+for+the+number+of+occurences.
++++//+final+hold+variable+of+corrected+word+up+to+the+npos=j
++++string+holdWord+=+"";
++++//+a+temp+var+in+order+to+replace+0+to+new+npos
++++string+holdTemp+=+"";
++++//+a+csv+for+a+an+entry+in+a+book+store
++++string+holdLetter+=+"Big+Java+7th+Ed,Horstman,978-1118431115,99.85";

++++//+j+=+npos
++++for+(int+j+=+0;+j+<+holdLetter.length();+j%2B%2B)+{

++++++++if+(holdLetter[j]+==+',')+{

++++++++++++if+(+count+==+0+)+
++++++++++++{+++++++++++
++++++++++++++++holdWord+=+holdLetter.replace(j,+1,+"+%7C+");++++++
++++++++++++}
++++++++++++else+{

++++++++++++++++string+holdTemp1+=+holdLetter.replace(j,+1,+"+%7C+");

++++++++++++++++//+since+replacement+is+three+positions+in+length,
++++++++++++++++//+must+replace+new+replacement's+0+to+npos-3,+with
++++++++++++++++//+the+0+to+npos+-+3+of+the+old+replacement+
++++++++++++++++holdTemp+=+holdTemp1.replace(0,+j-3,+holdWord,+0,+j-3);+

++++++++++++++++holdWord+=+"";

++++++++++++++++holdWord+=+holdTemp;

++++++++++++}
++++++++++++holdTemp+=+"";
++++++++++++count%2B%2B;
++++++++}
++++}+
++++cout+<<+holdWord+<<+endl;
++++return+0;
}

//+result:
Big+Java+7th+Ed+%7C+Horstman+%7C+978-1118431115+%7C+99.85|code-block|syntax|javascript|1977271|不同寻常的是，我目前使用的是CentOS，所以我的编译器版本低于这个版本。C%2B%2B版本(g%2B%2B)，C%2B%2B98默认值：|1977272|g%2B%2B+(GCC)+4.8.5+20150623+(Red+Hat+4.8.5-4)
Copyright+(C)+2015+Free+Software+Foundation,+Inc.
This+is+free+software;+see+the+source+for+copying+conditions.++There+is+NO
warranty;+not+even+for+MERCHANTABILITY+or+FITNESS+FOR+A+PARTICULAR+PURPOSE.|1977273|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! I used something similar to this for a bookstore app, where the inventory was stored in a CSV (like a .dat file). But in the case of a single char, meaning the replacer is only a single char, e.g.'|', it must be in double quotes "|" in order not to throw an invalid conversion const char. 

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

using namespace std;

int main()
{
 int count = 0; // for the number of occurences.
 // final hold variable of corrected word up to the npos=j
 string holdWord = "";
 // a temp var in order to replace 0 to new npos
 string holdTemp = "";
 // a csv for a an entry in a book store
 string holdLetter = "Big Java 7th Ed,Horstman,978-1118431115,99.85";

 // j = npos
 for (int j = 0; j &lt; holdLetter.length(); j++) {

 if (holdLetter[j] == ',') {

 if ( count == 0 ) 
 { 
 holdWord = holdLetter.replace(j, 1, " | "); 
 }
 else {

 string holdTemp1 = holdLetter.replace(j, 1, " | ");

 // since replacement is three positions in length,
 // must replace new replacement's 0 to npos-3, with
 // the 0 to npos - 3 of the old replacement 
 holdTemp = holdTemp1.replace(0, j-3, holdWord, 0, j-3); 

 holdWord = "";

 holdWord = holdTemp;

 }
 holdTemp = "";
 count++;
 }
 } 
 cout &lt;&lt; holdWord &lt;&lt; endl;
 return 0;
}

// result:
Big Java 7th Ed | Horstman | 978-1118431115 | 99.85
</code></pre>

Uncustomarily I am using CentOS currently, so my compiler version is below . The C++ version (g++), C++98 default:

<pre><code>g++ (GCC) 4.8.5 20150623 (Red Hat 4.8.5-4)
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
</code></pre>

blocks|key|1254484|text|如果您愿意使用std::strings，您可以按原样使用此示例应用程序的strsub函数，或者如果您希望它采用不同的类型或参数集来实现大致相同的目标，则可以更新它。基本上，它使用std::string的属性和功能来快速擦除匹配的字符集，并直接在std::string中插入所需的字符。每次执行此替换操作时，如果仍然可以找到要替换的匹配字符，则偏移量将更新，如果由于没有更多要替换的字符而无法找到，则返回上次更新时的状态的字符串。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1254485|#include+<iostream>
#include+<string>

std::string+strsub(std::string+stringToModify,
+++++++++++++++++++std::string+charsToReplace,
+++++++++++++++++++std::string+replacementChars);

int+main()
{
++++std::string+silly_typos+=+"annoiiyyyng+syyyllii+tiipos.";

++++std::cout+<<+"Look+at+these+"+<<+silly_typos+<<+std::endl;
++++silly_typos+=+strsub(silly_typos,+"yyy",+"i");
++++std::cout+<<+"After+a+little+elbow-grease,+a+few+less+"+<<+silly_typos+<<+std::endl;
++++silly_typos+=+strsub(silly_typos,+"ii",+"y");

++++std::cout+<<+"There,+no+more+"+<<+silly_typos+<<+std::endl;
++++return+0;
}

std::string+strsub(std::string+stringToModify,
+++++++++++++++++++std::string+charsToReplace,
+++++++++++++++++++std::string+replacementChars)
{
++++std::string+this_string+=+stringToModify;

++++std::size_t+this_occurrence+=+this_string.find(charsToReplace);
++++while+(this_occurrence+!=+std::string::npos)
++++{
++++++++this_string.erase(this_occurrence,+charsToReplace.size());
++++++++this_string.insert(this_occurrence,+replacementChars);
++++++++this_occurrence+=+this_string.find(charsToReplace,
+++++++++++++++++++++++++++++++++++++++++++this_occurrence+%2B+replacementChars.size());
++++}

++++return+this_string;
}|code-block|syntax|javascript|1254486|如果您不想依赖于使用std::strings作为参数，以便可以传入C样式的字符串，您可以在下面看到更新后的示例：|1254487|#include+<iostream>
#include+<string>

std::string+strsub(const+char+*+stringToModify,
+++++++++++++++++++const+char+*+charsToReplace,
+++++++++++++++++++const+char+*+replacementChars,
+++++++++++++++++++uint64_t+sizeOfCharsToReplace,
+++++++++++++++++++uint64_t+sizeOfReplacementChars);

int+main()
{
++++std::string+silly_typos+=+"annoiiyyyng+syyyllii+tiipos.";

++++std::cout+<<+"Look+at+these+"+<<+silly_typos+<<+std::endl;
++++silly_typos+=+strsub(silly_typos.c_str(),+"yyy",+"i",+3,+1);
++++std::cout+<<+"After+a+little+elbow-grease,+a+few+less+"+<<+silly_typos+<<+std::endl;
++++silly_typos+=+strsub(silly_typos.c_str(),+"ii",+"y",+2,+1);

++++std::cout+<<+"There,+no+more+"+<<+silly_typos+<<+std::endl;
++++return+0;
}

std::string+strsub(const+char+*+stringToModify,
+++++++++++++++++++const+char+*+charsToReplace,
+++++++++++++++++++const+char+*+replacementChars,
+++++++++++++++++++uint64_t+sizeOfCharsToReplace,
+++++++++++++++++++uint64_t+sizeOfReplacementChars)
{
++++std::string+this_string+=+stringToModify;

++++std::size_t+this_occurrence+=+this_string.find(charsToReplace);
++++while+(this_occurrence+!=+std::string::npos)
++++{
++++++++this_string.erase(this_occurrence,+sizeOfCharsToReplace);
++++++++this_string.insert(this_occurrence,+replacementChars);
++++++++this_occurrence+=+this_string.find(charsToReplace,
++++++++++++this_occurrence+%2B+sizeOfReplacementChars);
++++}

++++return+this_string;
}|1254488|entityMap^0|7|B|10|6|2H|B|3E|B|0|0|A|B|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$]]

If you're willing to use <code>std::string</code>s, you can use this sample-app's <code>strsub</code> function as-is, or update it if you want it to take a different type or set of parameters to achieve roughly the same goal. Basically, it uses the properties and functionalities of <code>std::string</code> to quickly erase the matching set of characters, and insert the desired characters directly within the <code>std::string</code>. Every time it does this replacement operation, the offset updates if it can still find matching chars to replace, and if it can't due to nothing more to replace, it returns the string in its state from the last update.

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

std::string strsub(std::string stringToModify,
 std::string charsToReplace,
 std::string replacementChars);

int main()
{
 std::string silly_typos = "annoiiyyyng syyyllii tiipos.";

 std::cout &lt;&lt; "Look at these " &lt;&lt; silly_typos &lt;&lt; std::endl;
 silly_typos = strsub(silly_typos, "yyy", "i");
 std::cout &lt;&lt; "After a little elbow-grease, a few less " &lt;&lt; silly_typos &lt;&lt; std::endl;
 silly_typos = strsub(silly_typos, "ii", "y");

 std::cout &lt;&lt; "There, no more " &lt;&lt; silly_typos &lt;&lt; std::endl;
 return 0;
}

std::string strsub(std::string stringToModify,
 std::string charsToReplace,
 std::string replacementChars)
{
 std::string this_string = stringToModify;

 std::size_t this_occurrence = this_string.find(charsToReplace);
 while (this_occurrence != std::string::npos)
 {
 this_string.erase(this_occurrence, charsToReplace.size());
 this_string.insert(this_occurrence, replacementChars);
 this_occurrence = this_string.find(charsToReplace,
 this_occurrence + replacementChars.size());
 }

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

If you don't want to rely on using <code>std::string</code>s as your parameters so you can pass in C-style strings instead, you can see the updated sample below:

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

std::string strsub(const char * stringToModify,
 const char * charsToReplace,
 const char * replacementChars,
 uint64_t sizeOfCharsToReplace,
 uint64_t sizeOfReplacementChars);

int main()
{
 std::string silly_typos = "annoiiyyyng syyyllii tiipos.";

 std::cout &lt;&lt; "Look at these " &lt;&lt; silly_typos &lt;&lt; std::endl;
 silly_typos = strsub(silly_typos.c_str(), "yyy", "i", 3, 1);
 std::cout &lt;&lt; "After a little elbow-grease, a few less " &lt;&lt; silly_typos &lt;&lt; std::endl;
 silly_typos = strsub(silly_typos.c_str(), "ii", "y", 2, 1);

 std::cout &lt;&lt; "There, no more " &lt;&lt; silly_typos &lt;&lt; std::endl;
 return 0;
}

std::string strsub(const char * stringToModify,
 const char * charsToReplace,
 const char * replacementChars,
 uint64_t sizeOfCharsToReplace,
 uint64_t sizeOfReplacementChars)
{
 std::string this_string = stringToModify;

 std::size_t this_occurrence = this_string.find(charsToReplace);
 while (this_occurrence != std::string::npos)
 {
 this_string.erase(this_occurrence, sizeOfCharsToReplace);
 this_string.insert(this_occurrence, replacementChars);
 this_occurrence = this_string.find(charsToReplace,
 this_occurrence + sizeOfReplacementChars);
 }

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

blocks|key|1977378|text|对于简单的情况，除了std::string+(已经在使用中)之外，不使用任何其他库就可以很好地工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1977379|将所有出现的character+a替换为character+b+in+some_string|offset|length|style|BOLD|1977380|for+(size_t+i+=+0;+i+<+some_string.size();+%2B%2Bi)+{
++++if+(some_string[i]+==+'a')+{
++++++++some_string.replace(i,+1,+"b");
++++}
}|code-block|syntax|javascript|1977381|如果字符串很大，或者需要多次调用替换，则可以应用以下答案中提到的技术：https://stackoverflow.com/a/29752943/3622300|1977382|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/29752943/3622300^0|0|G|1|U|1|Z|B|0|0|Z|18|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@$D|16|E|17|1|18]]|A|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

For simple situations this works pretty well without using any other library then std::string (which is already in use).

Replace all occurences of character a with character b in some_string:

<pre><code>for (size_t i = 0; i &lt; some_string.size(); ++i) {
 if (some_string[i] == 'a') {
 some_string.replace(i, 1, "b");
 }
}
</code></pre>

If the string is large or multiple calls to replace is an issue, you can apply the technique mentioned in this answer: <a href="https://stackoverflow.com/a/29752943/3622300">https://stackoverflow.com/a/29752943/3622300</a>

blocks|key|1251438|text|老派:-)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1251439|std::string+str+=+"H:/recursos/audio/youtube/libre/falta/";+

for+(int+i+=+0;+i+<+str.size();+i%2B%2B)+{
++++if+(str[i]+==+'/')+{
++++++++str[i]+=+'\\';
++++}
}

std::cout+<<+str;|code-block|syntax|javascript|1251440|结果：|1251441|1251442|+H:\recursos\audio\youtube\libre\falta\|blockquote|1251443|1251444|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|R|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|S|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|T|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|O|$]]

Old School :-)

<pre><code>std::string str = "H:/recursos/audio/youtube/libre/falta/"; 

for (int i = 0; i &lt; str.size(); i++) {
 if (str[i] == '/') {
 str[i] = '\\';
 }
}

std::cout &lt;&lt; str;
</code></pre>

Result:

<blockquote>
 H:\recursos\audio\youtube\libre\falta\
</blockquote>

blocks|key|1977407|text|那Abseil+StrReplaceAll呢？从头文件中：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1977408|//+This+file+defines+`absl::StrReplaceAll()`,+a+general-purpose+string
//+replacement+function+designed+for+large,+arbitrary+text+substitutions,
//+especially+on+strings+which+you+are+receiving+from+some+other+system+for
//+further+processing+(e.g.+processing+regular+expressions,+escaping+HTML
//+entities,+etc.).+`StrReplaceAll`+is+designed+to+be+efficient+even+when+only
//+one+substitution+is+being+performed,+or+when+substitution+is+rare.
//
//+If+the+string+being+modified+is+known+at+compile-time,+and+the+substitutions
//+vary,+`absl::Substitute()`+may+be+a+better+choice.
//
//+Example:
//
//+std::string+html_escaped+=+absl::StrReplaceAll(user_input,+{
//++++++++++++++++++++++++++++++++++++++++++++++++{"&",+"&amp;"},
//++++++++++++++++++++++++++++++++++++++++++++++++{"<",+"&lt;"},
//++++++++++++++++++++++++++++++++++++++++++++++++{">",+"&gt;"},
//++++++++++++++++++++++++++++++++++++++++++++++++{"\"",+"&quot;"},
//++++++++++++++++++++++++++++++++++++++++++++++++{"'",+"&#39;"}});|code-block|syntax|javascript|1977409|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/abseil/abseil-cpp/blob/master/absl/strings/str_replace.h^0|1|K|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

What about <a href="https://github.com/abseil/abseil-cpp/blob/master/absl/strings/str_replace.h" rel="nofollow noreferrer">Abseil StrReplaceAll</a>? From the header file:

<pre><code>// This file defines `absl::StrReplaceAll()`, a general-purpose string
// replacement function designed for large, arbitrary text substitutions,
// especially on strings which you are receiving from some other system for
// further processing (e.g. processing regular expressions, escaping HTML
// entities, etc.). `StrReplaceAll` is designed to be efficient even when only
// one substitution is being performed, or when substitution is rare.
//
// If the string being modified is known at compile-time, and the substitutions
// vary, `absl::Substitute()` may be a better choice.
//
// Example:
//
// std::string html_escaped = absl::StrReplaceAll(user_input, {
// {"&amp;", "&amp;amp;"},
// {"&lt;", "&amp;lt;"},
// {"&gt;", "&amp;gt;"},
// {"\"", "&amp;quot;"},
// {"'", "&amp;#39;"}});
</code></pre>

blocks|key|1251462|text|这是我用最大的DRI精神提出的解决方案。它将在sHaystack中搜索sNeedle，并将其替换为sReplace，如果不是0，则替换为nTimes，否则将替换所有sNeedle。它将不会在替换的文本中再次搜索。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1251463|std::string+str_replace(
++++std::string+sHaystack,+std::string+sNeedle,+std::string+sReplace,+
++++size_t+nTimes=0)
{
++++size_t+found+=+0,+pos+=+0,+c+=+0;
++++size_t+len+=+sNeedle.size();
++++size_t+replen+=+sReplace.size();
++++std::string+input(sHaystack);

++++do+{
++++++++found+=+input.find(sNeedle,+pos);
++++++++if+(found+==+std::string::npos)+{
++++++++++++break;
++++++++}
++++++++input.replace(found,+len,+sReplace);
++++++++pos+=+found+%2B+replen;
++++++++%2B%2Bc;
++++}+while(!nTimes+%7C%7C+c+<+nTimes);

++++return+input;
}|code-block|syntax|javascript|1251464|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|$]]

here's a solution i rolled, in a maximal DRI spirit.
it will search sNeedle in sHaystack and replace it by sReplace, 
nTimes if non 0, else all the sNeedle occurences.
it will not search again in the replaced text.

<pre><code>std::string str_replace(
 std::string sHaystack, std::string sNeedle, std::string sReplace, 
 size_t nTimes=0)
{
 size_t found = 0, pos = 0, c = 0;
 size_t len = sNeedle.size();
 size_t replen = sReplace.size();
 std::string input(sHaystack);

 do {
 found = input.find(sNeedle, pos);
 if (found == std::string::npos) {
 break;
 }
 input.replace(found, len, sReplace);
 pos = found + replen;
 ++c;
 } while(!nTimes || c &lt; nTimes);

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

blocks|key|507775|text|为了完整起见，下面是如何使用std::regex来做这件事。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|507776|#include+<regex>
#include+<string>

int+main()
{
++++const+std::string+s+=+"example+string";
++++const+std::string+r+=+std::regex_replace(s,+std::regex("x"),+"y");
}|code-block|syntax|javascript|507777|entityMap^0|E|A|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|$]]

For completeness, here's how to do it with <code>std::regex</code>.
<pre class="lang-cpp prettyprint-override"><code>#include &lt;regex&gt;
#include &lt;string&gt;

int main()
{
 const std::string s = &quot;example string&quot;;
 const std::string r = std::regex_replace(s, std::regex(&quot;x&quot;), &quot;y&quot;);
}
</code></pre>

blocks|key|3385352|text|这并不是标准库中唯一缺少的方法，它的设计初衷是低级的。此用例和许多其他用例都包含在通用库中，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3385353|3385354|POCO|unordered-list-item|offset|length|3385355|Abseil|3385356|Boost|3385357|QtCore|3385358|3385359|QtCore+&+QString有我的偏好:它支持UTF8，使用的模板更少，这意味着可以理解的错误和更快的编译。它使用"q“前缀，这使得名称空间变得不必要，并简化了头文件。|3385360|Boost通常会生成可怕的错误消息并降低编译速度。|3385361|POCO似乎是一个合理的折衷方案。|3385362|entityMap|0|LINK|mutability|MUTABLE|url|https://pocoproject.org/slides/040-StringsAndFormatting.pdf|1|https://abseil.io/docs/cpp/guides/strings|2|https://www.boost.org/doc/libs/1_63_0/doc/html/string_algo/usage.html#idp113236192|3|https://doc.qt.io/qt-5/qstring.html^0|0|0|0|4|0|0|0|6|1|0|0|5|2|0|0|6|3|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1A|8|@]|9|@$F|1B|G|1C|1|1D]]|A|$]]|$1|H|3|I|5|E|7|1E|8|@]|9|@$F|1F|G|1G|1|1H]]|A|$]]|$1|J|3|K|5|E|7|1I|8|@]|9|@$F|1J|G|1K|1|1L]]|A|$]]|$1|L|3|M|5|E|7|1M|8|@]|9|@$F|1N|G|1O|1|1P]]|A|$]]|$1|N|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1R|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1S|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1T|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]|12|$5|X|Y|Z|A|$10|13]]|14|$5|X|Y|Z|A|$10|15]]|16|$5|X|Y|Z|A|$10|17]]]]

This is not the only method missing from the standard library, it was intended be low level.
This use case and many other are covered by general libraries such as:
<ul>
<li><a href="https://pocoproject.org/slides/040-StringsAndFormatting.pdf" rel="nofollow noreferrer">POCO</a></li>
<li><a href="https://abseil.io/docs/cpp/guides/strings" rel="nofollow noreferrer">Abseil</a></li>
<li><a href="https://www.boost.org/doc/libs/1_63_0/doc/html/string_algo/usage.html#idp113236192" rel="nofollow noreferrer">Boost</a></li>
<li><a href="https://doc.qt.io/qt-5/qstring.html" rel="nofollow noreferrer">QtCore</a></li>
</ul>
QtCore &amp; QString has my preference: it supports UTF8 and uses less templates, which means understandable errors and faster compilation. It uses the &quot;q&quot; prefix which makes namespaces unnecessary and simplifies headers. 
Boost often generates hideous error messages and slow compile time. 
POCO seems to be a reasonable compromise.

blocks|key|3385397|text|我想我会用std::replace_if()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3385398|可以使用标准库函数编写一个简单的字符替换程序(由OP请求)。|3385399|对于在位版本：|3385400|#include+<string>
#include+<algorithm>

void+replace_char(std::string&+in,
++++++++++++++++++std::string::value_type+srch,
++++++++++++++++++std::string::value_type+repl)
{
++++std::replace_if(std::begin(in),+std::end(in),
++++++++++++++++++++[&srch](std::string::value_type+v)+{+return+v==srch;+},
++++++++++++++++++++repl);
++++return;
}|code-block|syntax|javascript|3385401|以及一个重载，如果输入是const字符串，则该重载返回副本：|3385402|std::string+replace_char(std::string+const&+in,
+++++++++++++++++++++++++std::string::value_type+srch,
+++++++++++++++++++++++++std::string::value_type+repl)
{
++++std::string+result{+in+};
++++replace_char(result,+srch,+repl);
++++return+result;
}|3385403|entityMap^0|5|H|0|0|0|0|C|5|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|Z|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|L|7|13|8|@]|D|@]|E|$M|N]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

I think I'd use <code>std::replace_if()</code>
A simple character-replacer (requested by OP) can be written by using standard library functions.
For an in-place version:
<pre><code>#include &lt;string&gt;
#include &lt;algorithm&gt;

void replace_char(std::string&amp; in,
 std::string::value_type srch,
 std::string::value_type repl)
{
 std::replace_if(std::begin(in), std::end(in),
 [&amp;srch](std::string::value_type v) { return v==srch; },
 repl);
 return;
}
</code></pre>
and an overload that returns a copy if the input is a <code>const</code> string:
<pre><code>std::string replace_char(std::string const&amp; in,
 std::string::value_type srch,
 std::string::value_type repl)
{
 std::string result{ in };
 replace_char(result, srch, repl);
 return result;
}
</code></pre>

What is the effective way to replace all occurrences of a character with another character in <code>std::string</code>?

How to replace all occurrences of a character in string?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在std::string中用一个字符替换所有出现的字符的有效方法是什么

问如何替换字符串中所有出现的字符？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何替换字符串中所有出现的字符？EN