Implementing a find-and-replace procedure in C++ - c++

Question

Just for fun, I'm trying to write a find-and-replace procedure like word processors have. I was wondering whether someone could help me figure out what I'm doing wrong (I'm getting a Timeout error) and could help me write a more elegant procedure.
#include <iostream>
#include <string>
void find_and_replace(std::string& text, const std::string& fword, const std::string& rword)
{
for (std::string::iterator it(text.begin()), offend(text.end()); it != offend;)
{
if (*it != ' ')
{
std::string::iterator wordstart(it);
std::string thisword;
while (*(it+1) != ' ' && (it+1) != offend)
thisword.push_back(*++it);
if (thisword == fword)
text.replace(wordstart, it, rword);
}
else {
++it;
}
}
}
int main()
{
std::string S("Yo, dawg, I heard you like ...");
std::string f("dawg");
std::string w("dog");
// Replace every instance of the word "dawg" with "dog":
find_and_replace(S, f, w);
std::cout << S;
return 0;
}

Answer 1

A find-and-replace like most editors have would involve regular
expressions. If all you're looking for is for literal
replacements, the function you need is std::search, to find
the text to be replaced, and std::string::replace, to do the
actual replacement. The only real issue you'll face:
std::string::replace can invalidate your iterators. You could
always start the search at the beginning of the string, but this
could lead to endless looping, if the replacement text contained
the search string (e.g. something like s/vector/std::vector/).
You should convert the the iterator returned from std::search
to an offset into the string before doing the replace (offset
= iter - str.begin()), and convert it back to an iterator after
(iter = str.begin() + offset + replacement.size()). (The
addition of replacement.size() is to avoid rescanning the text
you just inserted, which can lead to an infinite loop, for the
same reasons as presented above.)

Answer 2

using text.replace may invalidate any iterators into text (ie, both it and offend): this isn't safe
copying each character into a temporary string (which is created and destroyed every time you start a new word) is wasteful
The simplest thing that could possibly work is to:
use find to find the first matching substring: it returns a position which won't be invalidated when you replace substrings
check whether:
your substring is either at the start of the text, or preceded by a word separator
your substring is either at the end of the text, or succeeded by a word separator
if 2.1 and 2.2 are true, replace the substring
if you replaced it, increase position (from 1) by the length of your replacement string
otherwise increase position by the length of the string you searched for
repeat from 1, this time starting your find from position (from 4/5)
end when step 1 returns position std::string::npos.

Answer 3

1) you don't push first symbol of found word into "thisword" variable.
2) You use only space symbol ' ' as separator, and what about comma ','. Your program will find word "dawg," not "dawd"
The following code works, but you should think about other word separators. Do you really need to replace only whole word, or just sequence of symbols?
#include <iostream>
#include <string>
void find_and_replace(std::string& text, const std::string& fword, const std::string& rword)
{
for (std::string::iterator it(text.begin()), offend(text.end()); it != offend;)
{
if (*it != ' ' && *it != ',')
{
std::string::iterator wordstart(it);
std::string thisword;
while ((it) != offend && *(it) != ' ' && *(it) != ',')
thisword.push_back(*it++);
if (thisword == fword)
text.replace(wordstart, it, rword);
}
else {
++it;
}
}
}
int main()
{
std::string S("Yo, dawg, I heard you like ...");
std::string f("dawg");
std::string w("dog");
// Replace every instance of the word "dawg" with "dog":
find_and_replace(S, f, w);
std::cout << S;
return 0;
}