जवाबों:
अपनी खुद की जगह लागू क्यों नहीं?
void myReplace(std::string& str,
const std::string& oldStr,
const std::string& newStr)
{
std::string::size_type pos = 0u;
while((pos = str.find(oldStr, pos)) != std::string::npos){
str.replace(pos, oldStr.length(), newStr);
pos += newStr.length();
}
}#include <boost/algorithm/string.hpp> // include Boost, a C++ library
...
std::string target("Would you like a foo of chocolate. Two foos of chocolate?");
boost::replace_all(target, "foo", "bar");यहाँ रिप्लेसमेंट_ऑल पर आधिकारिक दस्तावेज है।
replace_allबढ़ावा देने के संस्करणों के लिए सेगफॉल्ट होगा> 1.43 किसी भी संस्करण के लिए सूर्य स्टूडियो पर <12.3
boostसंकलित उपकरणों पर काफी समय बढ़ जाता है। यहां तक कि ARMv7 क्वाड कोर। कोड की 100 लाइनें 2 मिनट में, बिना किसी सेकंड के, 2 सेकंड में संकलित होती हैं।
C ++ 11 में, आप इसे एक लाइनर के रूप में कॉल के साथ कर सकते हैं regex_replace:
#include <string>
#include <regex>
using std::string;
string do_replace( string const & in, string const & from, string const & to )
{
return std::regex_replace( in, std::regex(from), to );
}
string test = "Remove all spaces";
std::cout << do_replace(test, " ", "") << std::endl;उत्पादन:
Removeallspacesfromएक नियमित अभिव्यक्ति हो सकती है - इसलिए यदि आपको आवश्यकता हो तो आप अधिक परिष्कृत मिलान मानदंडों का उपयोग कर सकते हैं। मैं जो नहीं देखता, वह यह है कि नियमित अभिव्यक्ति पार्सिंग के कुछ रूप को लागू किए बिना ऐसा कैसे किया जाए - इसके बजाय केवल fromपात्रों की प्रत्यक्ष व्याख्या का उपयोग करें ।
संशोधित स्ट्रिंग क्यों नहीं लौटाते?
std::string ReplaceString(std::string subject, const std::string& search,
const std::string& replace) {
size_t pos = 0;
while((pos = subject.find(search, pos)) != std::string::npos) {
subject.replace(pos, search.length(), replace);
pos += replace.length();
}
return subject;
}यदि आपको प्रदर्शन की आवश्यकता है, तो यहां एक अनुकूलित फ़ंक्शन है जो इनपुट स्ट्रिंग को संशोधित करता है, यह स्ट्रिंग की प्रतिलिपि नहीं बनाता है:
void ReplaceStringInPlace(std::string& subject, const std::string& search,
const std::string& replace) {
size_t pos = 0;
while((pos = subject.find(search, pos)) != std::string::npos) {
subject.replace(pos, search.length(), replace);
pos += replace.length();
}
}टेस्ट:
std::string input = "abc abc def";
std::cout << "Input string: " << input << std::endl;
std::cout << "ReplaceString() return value: "
<< ReplaceString(input, "bc", "!!") << std::endl;
std::cout << "ReplaceString() input string not changed: "
<< input << std::endl;
ReplaceStringInPlace(input, "bc", "??");
std::cout << "ReplaceStringInPlace() input string modified: "
<< input << std::endl;आउटपुट:
Input string: abc abc def
ReplaceString() return value: a!! a!! def
ReplaceString() input string not modified: abc abc def
ReplaceStringInPlace() input string modified: a?? a?? defमेरे टेम्प-इन-इन-प्लेस खोज-इन-प्लेस:
template<class T>
int inline findAndReplace(T& source, const T& find, const T& replace)
{
int num=0;
typename T::size_t fLen = find.size();
typename T::size_t rLen = replace.size();
for (T::size_t pos=0; (pos=source.find(find, pos))!=T::npos; pos+=rLen)
{
num++;
source.replace(pos, fLen, replace);
}
return num;
}यह प्रतिस्थापित वस्तुओं की संख्या की गणना करता है (यदि आप इसे सफलतापूर्वक चलाना चाहते हैं, तो उपयोग के लिए आदि)। इसके प्रयेाग के लिए:
std::string str = "one two three";
int n = findAndReplace(str, "one", "1");सबसे आसान तरीका है (जो कुछ आपने लिखा है उसके पास की पेशकश) Boost.Regex , विशेष रूप से regex_replace का उपयोग करना है ।
std :: string को ढूँढने () और प्रतिस्थापित () विधियों में बनाया गया है, लेकिन वे काम करने के लिए अधिक बोझिल हैं क्योंकि उन्हें सूचकांक और स्ट्रिंग लंबाई से निपटने की आवश्यकता होती है।
मुझे विश्वास है कि यह काम करेगा। यह एक पैरामीटर के रूप में const char * लेता है।
//params find and replace cannot be NULL
void FindAndReplace( std::string& source, const char* find, const char* replace )
{
//ASSERT(find != NULL);
//ASSERT(replace != NULL);
size_t findLen = strlen(find);
size_t replaceLen = strlen(replace);
size_t pos = 0;
//search for the next occurrence of find within source
while ((pos = source.find(find, pos)) != std::string::npos)
{
//replace the found string with the replacement
source.replace( pos, findLen, replace );
//the next line keeps you from searching your replace string,
//so your could replace "hello" with "hello world"
//and not have it blow chunks.
pos += replaceLen;
}
}size_typeएक स्ट्रिंग के लिए unsigned, >=लूप की स्थिति में आपका चेक हमेशा रहेगा true। आपको std::string::nposवहां उपयोग करना होगा।
roll_down_window
// Replace all occurrences of searchStr in str with replacer
// Each match is replaced only once to prevent an infinite loop
// The algorithm iterates once over the input and only concatenates
// to the output, so it should be reasonably efficient
std::string replace(const std::string& str, const std::string& searchStr,
const std::string& replacer)
{
// Prevent an infinite loop if the input is empty
if (searchStr == "") {
return str;
}
std::string result = "";
size_t pos = 0;
size_t pos2 = str.find(searchStr, pos);
while (pos2 != std::string::npos) {
result += str.substr(pos, pos2-pos) + replacer;
pos = pos2 + searchStr.length();
pos2 = str.find(searchStr, pos);
}
result += str.substr(pos, str.length()-pos);
return result;
}#include <string>
using std::string;
void myReplace(string& str,
const string& oldStr,
const string& newStr) {
if (oldStr.empty()) {
return;
}
for (size_t pos = 0; (pos = str.find(oldStr, pos)) != string::npos;) {
str.replace(pos, oldStr.length(), newStr);
pos += newStr.length();
}
}OldStr खाली होने की जाँच महत्वपूर्ण है। यदि उस कारण से जो पैरामीटर खाली है, तो आप अनंत लूप में फंस जाएंगे।
लेकिन हाँ अगर आप कर सकते हैं की कोशिश की और परीक्षण C ++ 11 या बूस्ट समाधान का उपयोग करें।