Content      ..     35      36      37      38     ..

Working Draft, Standard for Programming Language C++ (N4713, 2017 year) - page 37

Table 116 — newoff values

Condition

newoff Value

way == ios_base::beg

0

way == ios_base::cur

the next pointer minus the begin-

ning pointer (xnext - xbeg).

way == ios_base::end the high mark pointer minus the

beginning pointer (high_mark -

xbeg).

pos_type seekpos(pos_type sp,

ios_base::openmode which

= ios_base::in | ios_base::out) override;

13

Effects: Equivalent to seekoff(off_type(sp), ios_base::beg, which).

14

Returns: sp to indicate success, or pos_type(off_type(-1)) to indicate failure.

basic_streambuf<charT, traits>* setbuf(charT* s, streamsize n);

15

Effects: implementation-defined, except that setbuf(0, 0) has no effect.

16

Returns: this.

30.8.3

Class template basic_istringstream

[istringstream]

namespace std {

template<class charT, class traits = char_traits<charT>,

class Allocator = allocator<charT>>

class basic_istringstream : public basic_istream<charT, traits> {

public:

using char_type

= charT;

using int_type

= typename traits::int_type;

using pos_type

= typename traits::pos_type;

using off_type

= typename traits::off_type;

using traits_type

= traits;

using allocator_type = Allocator;

// 30.8.3.1, constructors

explicit basic_istringstream(

ios_base::openmode which = ios_base::in);

explicit basic_istringstream(

const basic_string<charT, traits, Allocator>& str,

ios_base::openmode which = ios_base::in);

basic_istringstream(const basic_istringstream& rhs) = delete;

basic_istringstream(basic_istringstream&& rhs);

// 30.8.3.2, assign and swap

basic_istringstream& operator=(const basic_istringstream& rhs)

=

delete;

basic_istringstream& operator=(basic_istringstream&& rhs);

void swap(basic_istringstream& rhs);

// 30.8.3.3, members

basic_stringbuf<charT, traits, Allocator>* rdbuf() const;

basic_string<charT, traits, Allocator> str() const;

void str(const basic_string<charT, traits, Allocator>& s);

private:

basic_stringbuf<charT, traits, Allocator> sb; // exposition only

};

template<class charT, class traits, class Allocator>

void swap(basic_istringstream<charT, traits, Allocator>& x,

basic_istringstream<charT, traits, Allocator>& y);

}

§

30.8.3

1087

Table 117 — File open modes

ios_base flag combination

stdio equivalent

binary in out trunc app

+

"w"

+

+ "a"

+ "a"

+

+

"w"

+

"r"

+

+

"r+"

+

+

+

"w+"

+

+

+ "a+"

+

+ "a+"

+

+

"wb"

+

+

+ "ab"

+

+ "ab"

+

+

+

"wb"

+

+

"rb"

+

+

+

"r+b"

+

+

+

+

"w+b"

+

+

+

+ "a+b"

+

+

+ "a+b"

basic_filebuf* close();

7

Effects: If is_open() == false, returns a null pointer. If a put area exists, calls overflow(traits::

eof()) to flush characters. If the last virtual member function called on *this (between underflow,

overflow, seekoff, and seekpos) was overflow then calls a_codecvt.unshift (possibly several

times) to determine a termination sequence, inserts those characters and calls overflow(traits::

eof()) again. Finally, regardless of whether any of the preceding calls fails or throws an exception,

the function closes the file (as if by calling fclose(file)). If any of the calls made by the function,

including fclose, fails, close fails by returning a null pointer. If one of these calls throws an exception,

the exception is caught and rethrown after closing the file.

8

Returns: this on success, a null pointer otherwise.

9

Postconditions: is_open() == false.

30.9.2.4

Overridden virtual functions

[filebuf.virtuals]

streamsize showmanyc() override;

1

Effects: Behaves the same as basic_streambuf::showmanyc() (30.6.3.4).

2

Remarks: An implementation might well provide an overriding definition for this function signature if

it can determine that more characters can be read from the input sequence.

int_type underflow() override;

3

Effects: Behaves according to the description of basic_streambuf<charT, traits>::underflow(),

with the specialization that a sequence of characters is read from the input sequence as if by reading

from the associated file into an internal buffer (extern_buf) and then as if by doing:

char extern_buf[XSIZE];

char* extern_end;

charT intern_buf[ISIZE];

charT* intern_end;

codecvt_base::result r =

a_codecvt.in(state, extern_buf, extern_buf+XSIZE, extern_end,

intern_buf, intern_buf+ISIZE, intern_end);

§ 30.9.2.4

1095

pos_type seekoff(off_type off, ios_base::seekdir way,

ios_base::openmode which

= ios_base::in | ios_base::out) override;

13

Effects: Let width denote a_codecvt.encoding(). If is_open() == false, or off != 0 && width

<= 0, then the positioning operation fails. Otherwise, if way != basic_ios::cur or off != 0, and

if the last operation was output, then update the output sequence and write any unshift sequence.

Next, seek to the new position: if width > 0, call fseek(file, width * off, whence), otherwise

call fseek(file, 0, whence).

14

Remarks: “The last operation was output” means either the last virtual operation was overflow or

the put buffer is non-empty.

“Write any unshift sequence” means, if width if less than zero then

call a_codecvt.unshift(state, xbuf, xbuf+XSIZE, xbuf_end) and output the resulting unshift

sequence. The function determines one of three values for the argument whence, of type int, as

indicated in Table 118.

Table 118 — seekoff effects

way Value

stdio Equivalent

basic_ios::beg SEEK_SET

basic_ios::cur SEEK_CUR

basic_ios::end SEEK_END

15

Returns: A newly constructed pos_type object that stores the resultant stream position, if possible. If

the positioning operation fails, or if the object cannot represent the resultant stream position, returns

pos_type(off_type(-1)).

pos_type seekpos(pos_type sp,

ios_base::openmode which

= ios_base::in | ios_base::out) override;

16

Alters the file position, if possible, to correspond to the position stored in sp (as described below).

Altering the file position performs as follows:

1. if (om & ios_base::out) != 0, then update the output sequence and write any unshift sequence;

2. set the file position to sp as if by a call to fsetpos;

3. if (om & ios_base::in) != 0, then update the input sequence;

where om is the open mode passed to the last call to open(). The operation fails if is_open() returns

false.

17

If sp is an invalid stream position, or if the function positions neither sequence, the positioning operation

fails. If sp has not been obtained by a previous successful call to one of the positioning functions

(seekoff or seekpos) on the same file the effects are undefined.

18

Returns: sp on success. Otherwise returns pos_type(off_type(-1)).

int sync() override;

19

Effects: If a put area exists, calls filebuf::overflow to write the characters to the file, then flushes

the file as if by calling fflush(file). If a get area exists, the effect is implementation-defined.

void imbue(const locale& loc) override;

20

Requires: If the file is not positioned at its beginning and the encoding of the current locale as

determined by a_codecvt.encoding() is state-dependent (25.4.1.4.2) then that facet is the same as

the corresponding facet of loc.

21

Effects: Causes characters inserted or extracted after this call to be converted according to loc until

another call of imbue.

22

Remarks: This may require reconversion of previously converted characters. This in turn may require

the implementation to be able to reconstruct the original contents of the file.

§ 30.9.2.4

1097

Content      ..     35      36      37      38     ..