Ускорение работы алгоритма замены всех вхождений подстроки в строке

#include <iostream>
#include <string>
#include <fstream>
#include <optional>
#include <ctime>
#include <algorithm>
 
 
struct Args
{
    std::string inputFileName;
    std::string outputFileName;
    std::string searchString;
    std::string replaceString;
};
 
std::optional<Args> ParseArgs(int argc, char* argv[])
{
    if (argc != 5)
    {
        std::cout << "Invalid arguments count" << std::endl;
        std::cout << "Usage: replace.exe <input file name> <output file name> <search string> <replace string>" << std::endl;
        return std::nullopt;
    }
 
    Args args;
    args.inputFileName = argv[1];
    args.outputFileName = argv[2];
    args.searchString = argv[3];
    args.replaceString = argv[4];
    return args;
}
 
void ReplaceString(std::string& stringForReplace, const std::string& searchString, const std::string& replaceString)
{
 
    size_t searchStringSize = searchString.length();
    size_t replaceStringSize = replaceString.length();
 
    for (size_t indexChar = stringForReplace.find(searchString); indexChar != std::string::npos;)
    {
        stringForReplace.erase(indexChar, searchStringSize);
        stringForReplace.insert(indexChar, replaceString);
        indexChar = stringForReplace.find(searchString, indexChar + replaceStringSize);
    }
 
}
bool CheckFiles(std::ifstream& input, std::fstream& output, std::optional<Args> args)
{
    input.open(args->inputFileName);
    if (!input.is_open())
    {
        std::cout << "Failed to open '" << args->inputFileName << "' for reading." << std::endl;
        return false;
    }
 
    output.open(args->outputFileName);
    if (!output.is_open())
    {
        std::cout << "Failed to open '" << args->outputFileName << "' for writing." << std::endl;
        return false;
    }
    return true;
}
 
void Replace(std::ifstream& input, std::fstream& output, const std::optional<Args>& args)
{
    std::string stringForReplace;
    while (std::getline(input, stringForReplace))
    {
        if (stringForReplace.size() >= args->searchString.size())
        {
            ReplaceString(stringForReplace, args->searchString, args->replaceString);
            output << stringForReplace << std::endl;
        }
    }
}
 
int main(int argc, char* argv[])
{
    auto args = ParseArgs(argc, argv);
    if (!args.has_value())
    {
        return 1;
    }
 
    std::ifstream input;
    std::fstream output;
    if (!CheckFiles(input, output, args))
    {
        return 1;
    }
    Replace(input, output, args);
    std::cout << "runtime = " << clock() / 1000.0 << std::endl;
    return 0;

#include <iostream>
#include <string>
#include <fstream>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <functional>
#include <iterator>
#include <ctime>
 
// char str1[] = "AsdAsdAs";
// char str2[] = "BBsdBBsdBBs";
 
int main()
{
    std::fstream ifs{ "in.txt", std::ios::in | std::ios::binary }, ofs{"out.txt", std::ios::out | std::ios::binary}; // входной и выходной файлы
    if (!(ifs.is_open() && ofs.is_open()))
    {
        std::cerr << "Unable to open files\n";
        return 1;
    }
    char const* s1 = "A", *s2 = "BB"; // начальная и конечная подстроки (начальная должна состоять из одного символа)
    int s1l = strlen(s1);
    int s2l = strlen(s2);
    int coef = s2l / s1l + 1; 
    int len1 = 1000 * 1024, len2 = coef * len1;
    char* pb1 = new char[len1]; // входной буфер
    char* pb2 = new char[len2]; // выходной буфер
    while (true)
    {
        ifs.read(pb1, len1);
        int cread = ifs.gcount();
        if (cread != len1)
        {
            pb1[cread] = 0;
        }
        char* pnext = nullptr, *pprev = pb1, *pdest = pb2;
        for ( ; pnext = strstr(pprev, s1); pprev = pnext + s1l)
        {
            strncpy(pdest, pprev, pnext - pprev);
            pdest += pnext - pprev;
            strcpy(pdest, s2);
            pdest += s2l;
        }
        pnext = pb1 + cread;
        strncpy(pdest, pprev, pnext - pprev);
        pdest += pnext - pprev;
        int cwrite = pdest - pb2;
        ofs.write(pb2, cwrite);
 
        bool fff = ifs.fail();
        bool eee = ifs.eof();
        if (fff || eee)
        {
            break;
        }
    }
 
 
    delete[] pb1;
    pb1 = nullptr;
    delete[] pb2;
    pb2 = nullptr;
    ifs.close();
    ofs.close();
    std::cout << "runtime = " << clock() / 1000.0 << std::endl;
}

#include <iostream>
#include <string>
#include <fstream>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <functional>
#include <iterator>
#include <ctime>
 
// char str1[] = "AsdAsdAs";
// char str2[] = "BBsdBBsdBBs";
 
int main()
{
    std::fstream ifs{ "in.txt", std::ios::in | std::ios::binary }, ofs{ "out.txt", std::ios::out | std::ios::binary }; // входной и выходной файлы
    if (!(ifs.is_open() && ofs.is_open()))
    {
        std::cerr << "Unable to open files\n";
        return 1;
    }
    char const* s1 = "AAA", * s2 = "BBBB"; // начальная и конечная подстроки 
    int s1len = strlen(s1);
    int s2len = strlen(s2);
    int coef = s2len / s1len + 1;
    int len1 = 1000*1024, len2 = coef * len1, ctail = 0;
    char* pb1 = new char[len1]; // входной буфер
    char* pb2 = new char[len2]; // выходной буфер
    while (true)
    {
        ifs.read(pb1 + ctail, len1 - ctail);
        int cread = ifs.gcount() + ctail;
        if (cread != len1)
        {
            pb1[cread] = 0;
        }
        char* pnext = nullptr, * pprev = pb1, * pdest = pb2;
        int ncopy = 0;
        for (; pnext = strstr(pprev, s1); pprev = pnext + s1len)
        {
            ncopy = pnext - pprev;
            strncpy(pdest, pprev, ncopy);
            pdest += ncopy;
            strcpy(pdest, s2);
            pdest += s2len;
        }
        pnext = pb1 + cread;
        ncopy = pnext - pprev;
        strncpy(pdest, pprev, ncopy);
        pdest += ncopy;
 
        ctail = pnext - pprev;
        if (ctail >= s1len)
        {
            ctail = s1len - 1;
        }
 
        int cwrite = pdest - pb2;
        if (cread == len1)
        {
            cwrite -= ctail;
        }
        ofs.write(pb2, cwrite);
 
        memmove(pb1, pb1 + len1 - ctail, ctail);
 
        bool fff = ifs.fail();
        bool eee = ifs.eof();
        if (fff || eee)
        {
            break;
        }
    }
 
    delete[] pb1;
    pb1 = nullptr;
    delete[] pb2;
    pb2 = nullptr;
    ifs.close();
    ofs.close();
    std::cout << "runtime = " << clock() / 1000.0 << std::endl;
}