Best way to find and replace substrings in a char buffer?

Hello everybody!

I need to perform find and replace of certain substrings in a text that was
loaded from a text file into a char buffer, not into a std::string or
std::vector. So I thought of a function such as the following, which I found
at
http://www.linuxquestions.org/questions/programming-9/replace-a-substring-with-another-string-in-c-170076/

// Begin code.

#include <stdio.h>
#include <string.h>

char *replace_str(char *str, char *orig, char *rep)
{
  static char buffer[4096];
  char *p;

  if(!(p = strstr(str, orig))) // Is 'orig' even in 'str'?
    return str;

  strncpy(buffer, str, p-str); // Copy characters from 'str' start to 'orig'
st$
  buffer[p-str] = '\0';

  sprintf(buffer+(p-str), "%s%s", rep, p+strlen(orig));

  return buffer;
}

int main(void)
{
  puts(replace_str("Hello, world!", "world", "Miami"));

  return 0;
}

// End code.

The problem with this function is that it replaces only one occurrence of
the substring, so it would have to be called repeatedly until it returns
NULL, thus searching parts of the text many times over for nothing. Besides,
and this is even worse, it uses a fixed size buffer, which makes it rather
unpracticable for texts of arbitrary length.

Then I found the following function at
http://stackoverflow.com/questions/1494399/how-do-i-search-find-and-replace-in-an-stl-string

// Begin code.

template<class T> int inline findAndReplace(T& source, const T& find, const
T& replace)
{
     int num=0;
     T::size_t fLen = find.size();
     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;
}

// End code.

It looks like it works, but I wonder why it is a template - is there any
other STL container besides std::string that has a replace() function? I
think the following is better, which I found at the same site, as it uses a
std::string:

//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( it, 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;
     }
}

I feel like using this function, but the problem is that I am not sure
whether there is any reason not to construct a std::string from a char
buffer that was loaded from a text file, like "\0" characters for example -
is possible for a "\0" character to show up in the middle of a text file,
such messing up my find and replace function?

Unfortunately, std::vector does not seem to have a replace function,
otherwise I would construct an object of that type from the char buffer. So
would it be alright to use a std::string in this case?

--
Matthias Hofmann
Anvil-Soft, CEO
http://www.anvil-soft.com - The Creators of Toilet Tycoon
http://www.anvil-soft.de - Die Macher des Klomanagers

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]