I would like something that can window a std::string object into partitions of length N - for example (using a function update):

int main() {
  std::string s = "abcdefg";
  update<2>(s);
  return 0;
}

Calling the above should result in:

ab
bc
cd
ef
fg

I have the following version of the update function:

template<std::size_t size>
void update(std::string s) {
    std::string result(size, '\0');
    std::stringstream ss{s};
    int iterations = s.length() - size;
    for (int i = 0; i<iterations; i  ) {
        ss.read(&result[0], result.size());
        std::cout << result << std::endl;
    }
    return;
}

but this skips out combinations where the initial character lies at an odd index (the number of combinations is correct in my case, even though there is a repeat)

ab
cd
ef
gf
gf

A side note is that if there are any trailing characters then these should be omitted from the printed values (although I think this would be covered by the parameters of the for loop)

A final note is that I would like this to be as optimised as possible since I would typically be using strings of a very large length (>5M characters long) - my current solution may not be best for this so I am open to suggestions of alternative strategies.

CodePudding user response：

With C 17 you can do it like this, which is way more readable:

void update(std::string_view s, int size) {
    const int iterations = s.size() - size;
    for (int i = 0; i <= iterations; i  ) {
        std::cout << s.substr(i, size) << "\n";
    }
}

string_view is made exactly for this purpose, for fast read access to a string. string_view::substr is const complexity while string::substr is linear.

As a side note, besides what Nick mentioned, your code has few other small problems:

• std::endl fflushes the stream, it heavily impacts performance. Here you could just use '\n' to make a newline.
• the return at the end is absolutely redundant, void functions do not require returns
• what is the purpose of templating this? This will easily bloat your code without any measurable performance increase. Just pass the N as a parameter.
• also your main is declared as void and should be int (even more so as you do return a value at the end)

CodePudding user response：

With range-v3, you might use sliding view:

std::string s = "abcdefg";
for (auto r : s | ranges::views::sliding(2)) {
    std::cout << r << std::endl;
}

Demo

CodePudding user response：

Your call to ss.read will always read two characters, and then advance the ptr in the string stream 2 characters. So you never read/repeat the previous character at the start of each line.

If you want to do it "your way" then you have to keep track of the last character seperately.

    #include <iostream>
    #include <sstream>
    
    template<std::size_t size>
    void update(std::string s) {
        std::string result(size, '\0');
        char lastChar;
        std::stringstream ss{s};
        int iterations = s.length() - size;
        int read = 0;
        if (ss.readsome(&result[0], 1)) {
            lastChar = result[0];
        }
        for (int i = 0; i < iterations; i  ) {
            if (read = ss.readsome(&result[0], size - 1)) {
                std::cout << lastChar << result << std::endl;
                lastChar = result[read - 1];
            }
        }
    }

That being said, the above is definitely not the best approach performance wise. You should be able to do all of this without any string streams or read function, just iterating the string. Something like this

    #include <iostream>
    
    void update(std::string s, size_t size) {
        int len = s.length();
        for (int i = 1; i < len; i =size-1) {
            fwrite(&s[i-1], size, 1, stdout);
            putchar('\n');
        }
    }