std::basic_...buf::seekoff(3)

💖 NAME 💖

std::basic_stringbuf::seekoff — the manual literally spells it out as std::basic_stringbuf::seekoff - std::basic_stringbuf::seekoff, and this is the std::basic_...buf::seekoff(3) page from the C++ Standard Libary manual. We're talking about the protected virtual member that repositions stringbuf pointers, bestie. ✨

✨ Synopsis ✨

Okay so the signature is protected and virtual, and it's giving default-argument realness:

protected:

virtual pos_type seekoff( off_type off,
                          std::ios_base::seekdir dir,
                          std::ios_base::openmode which =
                              std::ios_base::in |
                              std::ios_base::out );

Repositions std::basic_streambuf::gptr and/or std::basic_streambuf::pptr, if possible, to the position that corresponds to exactly off characters from beginning, end, or current position of the get and/or put area of the buffer. 🫶

Here's the vibe check on when each pointer gets moved:

• If which includes std::ios_base::in and this buffer is open for reading (that is, if (which & std::ios_base::in) == std::ios_base::in), then repositions the read pointer std::basic_streambuf::gptr inside the get area as described below.
• If which includes std::ios_base::out and this buffer is open for writing (that is, (which & std::ios_base::out) == std::ios_base::out), then repositions the write pointer std::basic_streambuf::pptr inside the put area as described below.
• If which includes both std::ios_base::in and std::ios_base::out and the buffer is open for both reading and writing (that is, (which & (std::ios_base::in | std::ios_base::out)) == (std::ios_base::in | std::ios_base::out)), and dir is either std::ios_base::beg or std::ios_base::end, then repositions both read and write pointers as described below.
• Otherwise, this function fails. 😭

If gptr and/or pptr is repositioned, it is done as follows:

1. The new pointer offset newoff of type off_type is determined:
   • a) if dir == std::ios_base::beg, then newoff is zero
   • b) if dir == std::ios_base::cur, then newoff is the current position of the pointer (gptr() - eback() or pptr() - pbase())
   • c) if dir == std::ios_base::end, then newoff is the length of the entire initialized part of the buffer (if over-allocation is used, the high watermark pointer minus the beginning pointer)
2. If the pointer to be repositioned is a null pointer and newoff would be non-zero, this function fails.
3. If newoff + off < 0 (the repositioning would move the pointer to before the beginning of the buffer) or if newoff + off would point past the end of the buffer (or past the last initialized character in the buffer if over-allocation is used), the function fails.
4. Otherwise, the pointer is assigned as if by gptr() = eback() + newoff + off or pptr() = pbase() + newoff + off.

---

🎀 Parameters 🎀

The manual labels these Constant / Explanation, so here's the group-chat translation that keeps every constant:

• off — relative position to set the next pointer(s) to.
• dir — defines base position to apply the relative offset to. It can be one of the following constants:
  • beg — the beginning of a stream
  • end — the ending of a stream
  • cur — the current position of stream position indicator
• which — defines whether the input sequences, the output sequence, or both are affected. It can be one or a combination of the following constants:
  • in — affect the input sequence
  • out — affect the output sequence

🫶 Return value 🫶

pos_type(newoff) on success, pos_type(off_type(-1)) on failure or if pos_type cannot represent the resulting stream position. So success gives you pos_type(newoff); failure or can't-represent gives you pos_type(off_type(-1)). No cap. 💀

---

🌸 Example 🌸

Code is sacred, so here it is exactly:

// Run this code

#include <iostream>
#include <sstream>

int main()
{
    std::stringstream ss("123"); // in/out
    std::cout << "put pos = " << ss.tellp()
              << " get pos = " << ss.tellg() << '\n';

    // absolute positioning both pointers
    ss.rdbuf()->pubseekoff(1, std::ios_base::beg); // move both 1 forward
    std::cout << "put pos = " << ss.tellp()
              << " get pos = " << ss.tellg() << '\n';

    // try to move both pointers 1 forward from current position
    if (-1 == ss.rdbuf()->pubseekoff(1, std::ios_base::cur))
        std::cout << "moving both pointers from current position failed\n";
    std::cout << "put pos = " << ss.tellp()
              << " get pos = " << ss.tellg() << '\n';

    // move the write pointer 1 forward, but not the read pointer
    // can also be called as ss.seekp(1, std::ios_base::cur);
    ss.rdbuf()->pubseekoff(1, std::ios_base::cur, std::ios_base::out);
    std::cout << "put pos = " << ss.tellp()
              << " get pos = " << ss.tellg() << '\n';

    ss << 'a'; // write at put position
    std::cout << "Wrote 'a' at put position, the buffer is now " << ss.str() << '\n';

    char ch;
    ss >> ch;
    std::cout << "reading at get position gives '" << ch << "'\n";
}

Output:

put pos = 0 get pos = 0
put pos = 1 get pos = 1
moving both pointers from current position failed
put pos = 1 get pos = 1
put pos = 2 get pos = 1
Wrote 'a' at put position, the buffer is now 12a
reading at get position gives '2'

🦋 Defect reports 🦋

These behavior-changing defect reports were applied retroactively to previously published C++ standards. History really said "let's fix it" and we're obsessed:

• LWG 55 — applied to C++98. Behavior as published: seekoff returned an undefined invalid stream position on failure. Correct behavior: pos_type(off_type(-1)) is returned on failure.
• LWG 375 — applied to C++98. Behavior as published: static constant members of std::ios_base were misspecified as members of std::basic_ios. Correct behavior: corrected.
• LWG 432 — applied to C++98. Behavior as published: seekoff might succeed even if newoff + off would point past the last initialized character. Correct behavior: seekoff fails in this case.
• LWG 453 — applied to C++98. Behavior as published: repositioning null gptr() and/or null pptr() with a new offset of zero always failed. Correct behavior: it can succeed in this case.
• LWG 563 — applied to C++98. Behavior as published: the end pointer could not be used to calculate newoff because it could not be precisely controlled by the program after resolving LWG issue 432. Correct behavior: use the high watermark pointer instead.

👑 See also 👑

These are the linked besties, with every parenthetical intact:

• pubseekoff — invokes seekoff() (public member function of std::basic_streambuf<CharT,Traits>)
• seekpos [virtual] — repositions the next pointer in the input sequence, output sequence, or both using absolute addressing (virtual protected member function)
• seekoff [virtual] — repositions the file position, using relative addressing (virtual protected member function of std::basic_filebuf<CharT,Traits>)
• seekoff [virtual] — repositions the next pointer in the input sequence, output sequence, or both, using relative addressing (virtual protected member function of std::strstreambuf)

---

Bye bestie! This was the std::basic_...buf::seekoff(3) page from the C++ Standard Libary manual. Source/version/date: http://cppreference.com, 2024.06.10. Mwah 💋✨