%!TEX root = std.tex

\normannex{depr}{Compatibility features}

\rSec1[depr.general]{General}

\pnum

This Annex describes features of the \Cpp{} Standard that are specified for compatibility with

existing implementations.

\pnum

These are deprecated features, where

\term{deprecated}

is defined as:

Normative for the current revision of \Cpp{},

but having been identified as a candidate for removal from future revisions.

An implementation may declare library names and entities described in this Clause with the

\tcode{deprecated} attribute\iref{dcl.attr.deprecated}.

\rSec1[depr.arith.conv.enum]{Arithmetic conversion on enumerations}

\pnum

The ability to apply the usual arithmetic conversions\iref{expr.arith.conv}

on operands where one is of enumeration type

and the other is of a different enumeration type

or a floating-point type

is deprecated.

\begin{note}

Three-way comparisons\iref{expr.spaceship} between such operands are ill-formed.

\end{note}

\begin{example}

\begin{codeblock}

enum E1 { e };

enum E2 { f };

bool b = e <= 3.7; // deprecated

int k = f - e; // deprecated

auto cmp = e <=> f; // error

\end{codeblock}

\end{example}

\rSec1[depr.capture.this]{Implicit capture of \tcode{*this} by reference}

\pnum

For compatibility with prior revisions of \Cpp{},

a \grammarterm{lambda-expression} with \grammarterm{capture-default}

\tcode{=}\iref{expr.prim.lambda.capture} may implicitly capture

\tcode{*this} by reference.

\begin{example}

\begin{codeblock}

struct X {

int x;

void foo(int n) {

auto f = [=]() { x = n; }; // deprecated: \tcode{x} means \tcode{this->x}, not a copy thereof

auto g = [=, this]() { x = n; }; // recommended replacement

}

};

\end{codeblock}

\end{example}

\rSec1[depr.array.comp]{Array comparisons}

\pnum

Equality and relational comparisons\iref{expr.eq,expr.rel}

between two operands of array type

are deprecated.

\begin{note}

Three-way comparisons\iref{expr.spaceship} between such operands are ill-formed.

\end{note}

\begin{example}

\begin{codeblock}

int arr1[5];

int arr2[5];

bool same = arr1 == arr2; // deprecated, same as \tcode{\&arr1[0] == \&arr2[0]},

// does not compare array contents

auto cmp = arr1 <=> arr2; // error

\end{codeblock}

\end{example}

\rSec1[depr.volatile.type]{Deprecated \tcode{volatile} types}

\pnum

Postfix \tcode{++} and \tcode{--} expressions\iref{expr.post.incr} and

prefix \tcode{++} and \tcode{--} expressions\iref{expr.pre.incr}

of volatile-qualified arithmetic and pointer types are deprecated.

\begin{example}

\begin{codeblock}

volatile int velociraptor;

++velociraptor; // deprecated

\end{codeblock}

\end{example}

\pnum

Certain assignments

where the left operand is a volatile-qualified non-class type

are deprecated; see~\ref{expr.ass}.

\begin{example}

\begin{codeblock}

int neck, tail;

volatile int brachiosaur;

brachiosaur = neck; // OK

tail = brachiosaur; // OK

tail = brachiosaur = neck; // deprecated

brachiosaur += neck; // OK

\end{codeblock}

\end{example}

\pnum

A function type\iref{dcl.fct}

with a parameter with volatile-qualified type or

with a volatile-qualified return type is deprecated.

\begin{example}

\begin{codeblock}

volatile struct amber jurassic(); // deprecated

void trex(volatile short left_arm, volatile short right_arm); // deprecated

void fly(volatile struct pterosaur* pteranodon); // OK

\end{codeblock}

\end{example}

\pnum

A structured binding\iref{dcl.struct.bind} of a volatile-qualified type

is deprecated.

\begin{example}

\begin{codeblock}

struct linhenykus { short forelimb; };

void park(linhenykus alvarezsauroid) {

volatile auto [what_is_this] = alvarezsauroid; // deprecated

// ...

}

\end{codeblock}

\end{example}

\rSec1[depr.static.constexpr]{Redeclaration of \tcode{static constexpr} data members}

\pnum

For compatibility with prior revisions of \Cpp{}, a \keyword{constexpr}

static data member may be redundantly redeclared outside the class with no

initializer\iref{basic.def,class.static.data}.

This usage is deprecated.

\begin{example}

\begin{codeblock}

struct A {

static constexpr int n = 5; // definition (declaration in \CppXIV{})

};

constexpr int A::n; // redundant declaration (definition in \CppXIV{})

\end{codeblock}

\end{example}

\rSec1[depr.local]{Non-local use of TU-local entities}

\pnum

A declaration of a non-TU-local entity that is an exposure\iref{basic.link}

is deprecated.

\begin{note}

Such a declaration in an importable module unit is ill-formed.

\end{note}

\begin{example}

\begin{codeblock}

namespace {

struct A {

void f() {}

};

}

A h(); // deprecated: not internal linkage

inline void g() {A().f();} // deprecated: inline and not internal linkage

\end{codeblock}

\end{example}

\rSec1[depr.impldec]{Implicit declaration of copy functions}

\pnum

The implicit definition of a copy constructor\iref{class.copy.ctor}

as defaulted is deprecated if the class has

a user-declared copy assignment operator or

a user-declared destructor\iref{class.dtor}.

The implicit definition of a copy assignment operator\iref{class.copy.assign}

as defaulted is deprecated if the class has

a user-declared copy constructor or

a user-declared destructor.

It is possible that future versions of \Cpp{} will specify

that these implicit definitions are deleted\iref{dcl.fct.def.delete}.

\rSec1[depr.lit]{Literal operator function declarations using an identifier}

\pnum

A \grammarterm{literal-operator-id}\iref{over.literal} of the form

\begin{codeblock}

operator @\grammarterm{string-literal}@ @\grammarterm{identifier}@

\end{codeblock}

is deprecated.

\rSec1[depr.template.template]{\tcode{template} keyword before qualified names}

\pnum

The use of the keyword \keyword{template}

before the qualified name of a class or alias template

without a template argument list is deprecated\iref{temp.names}.

\rSec1[depr.numeric.limits.has.denorm]{\tcode{has_denorm} members in \tcode{numeric_limits}}

\pnum

The following type is defined

in addition to those specified in \libheaderref{limits}:

\indexlibraryglobal{float_denorm_style}%

\begin{codeblock}

namespace std {

enum float_denorm_style {

denorm_indeterminate = -1,

denorm_absent = 0,

denorm_present = 1

};

}

\end{codeblock}

\pnum

\indextext{denormalized value|see{number, subnormal}}%

\indextext{value!denormalized|see{number, subnormal}}%

\indextext{subnormal number|see{number, subnormal}}%

\indextext{number!subnormal}%

The following members are defined

in addition to those specified in \ref{numeric.limits.general}:

\begin{codeblock}

static constexpr float_denorm_style has_denorm = denorm_absent;

static constexpr bool has_denorm_loss = false;

\end{codeblock}

\pnum

The values of \tcode{has_denorm} and \tcode{has_denorm_loss} of

specializations of \tcode{numeric_limits} are unspecified.

\pnum

The following members of the specialization \tcode{numeric_limits<bool>} are defined

in addition to those specified in \ref{numeric.special}:

\indexlibrarymember{float_denorm_style}{numeric_limits}%

\indexlibrarymember{has_denorm_loss}{numeric_limits}%

\begin{codeblock}

static constexpr float_denorm_style has_denorm = denorm_absent;

static constexpr bool has_denorm_loss = false;

\end{codeblock}

\rSec1[depr.c.macros]{Deprecated C macros}

\pnum

The header \libheader{stdalign.h} has the following macro:

\indexheader{stdalign.h}%

\indexlibraryglobal{__alignas_is_defined}%

\begin{codeblock}

#define @\xname{alignas_is_defined}@ 1

\end{codeblock}

\pnum

The header \libheader{stdbool.h} has the following macro:

\indexheader{stdbool.h}%

\indexhdr{stdbool.h}%

\indexlibraryglobal{__bool_true_false_are_defined}%

\begin{codeblock}

#define @\xname{bool_true_false_are_defined}@ 1

\end{codeblock}

\rSec1[depr.relops]{Relational operators}%

\indexlibraryglobal{rel_ops}%

\pnum

The header \libheaderref{utility} has the following additions:

\begin{codeblock}

namespace std::rel_ops {

template<class T> bool operator!=(const T&, const T&);

template<class T> bool operator> (const T&, const T&);

template<class T> bool operator<=(const T&, const T&);

template<class T> bool operator>=(const T&, const T&);

}

\end{codeblock}

\pnum

To avoid redundant definitions of \tcode{operator!=} out of \tcode{operator==}

and operators \tcode{>}, \tcode{<=}, and \tcode{>=} out of \tcode{operator<},

the library provides the following:

\indexlibrary{\idxcode{operator"!=}}%

\begin{itemdecl}

template<class T> bool operator!=(const T& x, const T& y);

\end{itemdecl}

\begin{itemdescr}

\pnum

\expects

\tcode{T} meets the \oldconcept{EqualityComparable} requirements (\tref{cpp17.equalitycomparable}).

\pnum

\returns

\tcode{!(x == y)}.

\end{itemdescr}

\indexlibraryglobal{operator>}%

\begin{itemdecl}

template<class T> bool operator>(const T& x, const T& y);

\end{itemdecl}

\begin{itemdescr}

\pnum

\expects

\tcode{T} meets the \oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).

\pnum

\returns

\tcode{y < x}.

\end{itemdescr}

\indexlibrary{\idxcode{operator<=}}%

\begin{itemdecl}

template<class T> bool operator<=(const T& x, const T& y);

\end{itemdecl}

\begin{itemdescr}

\pnum

\expects

\tcode{T} meets the \oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).

\pnum

\returns

\tcode{!(y < x)}.

\end{itemdescr}

\indexlibrary{\idxcode{operator>=}}%

\begin{itemdecl}

template<class T> bool operator>=(const T& x, const T& y);

\end{itemdecl}

\begin{itemdescr}

\pnum

\expects

\tcode{T} meets the \oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).

\pnum

\returns

\tcode{!(x < y)}.

\end{itemdescr}

\rSec1[depr.str.strstreams]{\tcode{char*} streams}

\rSec2[depr.strstream.syn]{Header \tcode{<strstream>} synopsis}

\pnum

The header \libheaderdef{strstream}

defines types that associate stream buffers with

character array objects and assist reading and writing such objects.

\begin{codeblock}

namespace std {

class strstreambuf;

class istrstream;

class ostrstream;

class strstream;

}

\end{codeblock}

\rSec2[depr.strstreambuf]{Class \tcode{strstreambuf}}

\rSec3[depr.strstreambuf.general]{General}

\indexlibraryglobal{strstreambuf}%

\begin{codeblock}

namespace std {

class strstreambuf : public basic_streambuf<char> {

public:

strstreambuf() : strstreambuf(0) {}

explicit strstreambuf(streamsize alsize_arg);

strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));

strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = nullptr);

strstreambuf(const char* gnext_arg, streamsize n);

strstreambuf(signed char* gnext_arg, streamsize n,

signed char* pbeg_arg = nullptr);

strstreambuf(const signed char* gnext_arg, streamsize n);

strstreambuf(unsigned char* gnext_arg, streamsize n,

unsigned char* pbeg_arg = nullptr);

strstreambuf(const unsigned char* gnext_arg, streamsize n);

virtual ~strstreambuf();

void freeze(bool freezefl = true);

char* str();

int pcount();

protected:

int_type overflow (int_type c = EOF) override;

int_type pbackfail(int_type c = EOF) override;

int_type underflow() override;

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

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

pos_type seekpos(pos_type sp,

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

streambuf* setbuf(char* s, streamsize n) override;

private:

using strstate = T1; // \expos

static const strstate allocated; // \expos

static const strstate constant; // \expos

static const strstate dynamic; // \expos

static const strstate frozen; // \expos

strstate strmode; // \expos

streamsize alsize; // \expos

void* (*palloc)(size_t); // \expos

void (*pfree)(void*); // \expos

};

}

\end{codeblock}

\pnum

The class

\tcode{strstreambuf}

associates the input sequence, and possibly the output sequence, with an object of some

\textit{character}

array type, whose elements store arbitrary values.

The array object has several attributes.

\pnum

\begin{note}

For the sake of exposition, these are represented as elements of a bitmask type

(indicated here as \tcode{T1}) called \tcode{strstate}.

The elements are:

\begin{itemize}

\item

\tcode{allocated}, set when a dynamic array object has been

allocated, and hence will be freed by the destructor for the

\tcode{strstreambuf} object;

\item

\tcode{constant}, set when the array object has

\keyword{const} elements, so the output sequence cannot be written;

\item

\tcode{dynamic}, set when the array object is allocated

(or reallocated)

as necessary to hold a character sequence that can change in length;

\item

\tcode{frozen}, set when the program has requested that the

array object not be altered, reallocated, or freed.

\end{itemize}

\end{note}

\pnum

\begin{note}

For the sake of exposition, the maintained data is presented here as:

\begin{itemize}

\item

\tcode{strstate strmode}, the attributes of the array object

associated with the \tcode{strstreambuf} object;

\item

\tcode{int alsize}, the suggested minimum size for a

dynamic array object;

\item

\tcode{void* (*palloc)(size_t)}, points to the function

to call to allocate a dynamic array object;

\item

\tcode{void (*pfree)(void*)}, points to the function to

call to free a dynamic array object.

\end{itemize}

\end{note}

\pnum

Each object of class

\tcode{strstreambuf}

has a

\term{seekable area},

delimited by the pointers \tcode{seeklow} and \tcode{seekhigh}.

If \tcode{gnext} is a null pointer, the seekable area is undefined.

Otherwise, \tcode{seeklow} equals \tcode{gbeg} and

\tcode{seekhigh} is either \tcode{pend},

if \tcode{pend} is not a null pointer, or \tcode{gend}.

\rSec3[depr.strstreambuf.cons]{\tcode{strstreambuf} constructors}

\indexlibraryctor{strstreambuf}%

\begin{itemdecl}

explicit strstreambuf(streamsize alsize_arg);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Initializes the base class with \tcode{streambuf()}.

The postconditions of this function are indicated in \tref{depr.strstreambuf.cons.sz}.

\end{itemdescr}

\begin{libtab2}{\tcode{strstreambuf(streamsize)} effects}{depr.strstreambuf.cons.sz}

{ll}

{Element}{Value}

\tcode{strmode} & \tcode{dynamic} \\

\tcode{alsize} & \tcode{alsize_arg} \\

\tcode{palloc} & a null pointer \\

\tcode{pfree} & a null pointer \\

\end{libtab2}

\indexlibraryctor{strstreambuf}%

\begin{itemdecl}

strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Initializes the base class with \tcode{streambuf()}.

The postconditions of this function are indicated in \tref{depr.strstreambuf.cons.alloc}.

\begin{libtab2}{\tcode{strstreambuf(void* (*)(size_t), void (*)(void*))} effects}

{depr.strstreambuf.cons.alloc}

{ll}

{Element}{Value}

\tcode{strmode} & \tcode{dynamic} \\

\tcode{alsize} & an unspecified value \\

\tcode{palloc} & \tcode{palloc_arg} \\

\tcode{pfree} & \tcode{pfree_arg} \\

\end{libtab2}

\end{itemdescr}

\indextext{unspecified}%

\indexlibraryctor{strstreambuf}%

\begin{itemdecl}

strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = nullptr);

strstreambuf(signed char* gnext_arg, streamsize n,

signed char* pbeg_arg = nullptr);

strstreambuf(unsigned char* gnext_arg, streamsize n,

unsigned char* pbeg_arg = nullptr);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Initializes the base class with \tcode{streambuf()}.

The postconditions of this function are indicated in \tref{depr.strstreambuf.cons.ptr}.

\begin{libtab2}{\tcode{strstreambuf(charT*, streamsize, charT*)} effects}

{depr.strstreambuf.cons.ptr}

{ll}

{Element}{Value}

\tcode{strmode} & 0 \\

\tcode{alsize} & an unspecified value \\

\tcode{palloc} & a null pointer \\

\tcode{pfree} & a null pointer \\

\end{libtab2}

\pnum

\tcode{gnext_arg} shall point to the first element of an array

object whose number of elements \tcode{N} is determined as follows:

\begin{itemize}

\item

If

\tcode{n > 0},

\tcode{N} is \tcode{n}.

\item

If

\tcode{n == 0},

\tcode{N} is

\tcode{std::strlen(gnext_arg)}.

\indexlibraryglobal{strlen}%

\item

If

\tcode{n < 0},

\tcode{N} is

\tcode{INT_MAX}.

\begin{footnote}

The function signature

\indexlibraryglobal{strlen}%

\tcode{strlen(const char*)}

is declared in \libheaderref{cstring}.

The macro \tcode{INT_MAX} is defined in \libheaderref{climits}.

\end{footnote}

\end{itemize}

\pnum

If \tcode{pbeg_arg} is a null pointer, the function executes:

\begin{codeblock}

setg(gnext_arg, gnext_arg, gnext_arg + N);

\end{codeblock}

\pnum

Otherwise, the function executes:

\begin{codeblock}

setg(gnext_arg, gnext_arg, pbeg_arg);

setp(pbeg_arg, pbeg_arg + N);

\end{codeblock}

\end{itemdescr}

\indexlibraryctor{strstreambuf}%

\begin{itemdecl}

strstreambuf(const char* gnext_arg, streamsize n);

strstreambuf(const signed char* gnext_arg, streamsize n);

strstreambuf(const unsigned char* gnext_arg, streamsize n);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Behaves the same as

\tcode{strstreambuf((char*)gnext_arg,n)},

except that the constructor also sets \tcode{constant} in \tcode{strmode}.

\end{itemdescr}

\indexlibrarydtor{strstreambuf}%

\begin{itemdecl}

virtual ~strstreambuf();

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Destroys an object of class

\tcode{strstreambuf}.

The function frees the dynamically allocated array object only if

\tcode{(strmode \& allocated) != 0}

and

\tcode{(strmode \& frozen) == 0}.

(\ref{depr.strstreambuf.virtuals} describes how a dynamically allocated array object is freed.)

\end{itemdescr}

\rSec3[depr.strstreambuf.members]{Member functions}

\indexlibrarymember{freeze}{strstreambuf}%

\begin{itemdecl}

void freeze(bool freezefl = true);

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

If \tcode{strmode \& dynamic} is nonzero, alters the

freeze status of the dynamic array object as follows:

\begin{itemize}

\item

If \tcode{freezefl} is

\tcode{true},

the function sets \tcode{frozen} in \tcode{strmode}.

\item

Otherwise, it clears \tcode{frozen} in \tcode{strmode}.

\end{itemize}

\end{itemdescr}

\indexlibrarymember{str}{strstreambuf}%

\begin{itemdecl}

char* str();

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Calls

\tcode{freeze()},

then returns the beginning pointer for the input sequence, \tcode{gbeg}.

\pnum

\remarks

The return value can be a null pointer.

\end{itemdescr}

\indexlibrarymember{pcount}{strstreambuf}%

\begin{itemdecl}

int pcount() const;

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

If the next pointer for the output sequence, \tcode{pnext}, is

a null pointer, returns zero.

Otherwise, returns the current

effective length of the array object as the next pointer minus the beginning

pointer for the output sequence, \tcode{pnext - pbeg}.

\end{itemdescr}

\rSec3[depr.strstreambuf.virtuals]{\tcode{strstreambuf} overridden virtual functions}

\indexlibrarymember{overflow}{strstreambuf}%

\begin{itemdecl}

int_type overflow(int_type c = EOF) override;

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Appends the character designated by \tcode{c} to the output

sequence, if possible, in one of two ways:

\begin{itemize}

\item

If

\tcode{c != EOF}

and if either the output sequence has a write position available or

the function makes a write position available

(as described below),

assigns \tcode{c} to

\tcode{*pnext++}.

Returns

\tcode{(unsigned char)c}.

\item

If

\tcode{c == EOF},

there is no character to append.

Returns a value other than \tcode{EOF}.

\end{itemize}

\pnum

Returns

\tcode{EOF}

to indicate failure.

\pnum

\remarks

The function can alter the number of write positions available as a

result of any call.

\pnum

To make a write position available, the function reallocates

(or initially allocates)

an array object with a sufficient number of elements

\tcode{n} to hold the current array object (if any),

plus at least one additional write position.

How many additional write positions are made

available is otherwise unspecified.%

\indextext{unspecified}%

If \tcode{palloc} is not a null pointer, the function calls

\tcode{(*palloc)(n)}

to allocate the new dynamic array object.

Otherwise, it evaluates the expression

\tcode{new charT[n]}.

In either case, if the allocation fails, the function returns

\tcode{EOF}.

Otherwise, it sets \tcode{allocated} in \tcode{strmode}.

\pnum

To free a previously existing dynamic array object whose first

element address is \tcode{p}:

If \tcode{pfree} is not a null pointer,

the function calls

\tcode{(*pfree)(p)}.

Otherwise, it evaluates the expression \tcode{delete[]p}.

\pnum

If

\tcode{(strmode \& dynamic) == 0},

or if

\tcode{(strmode \& frozen) != 0},

the function cannot extend the array (reallocate it with greater length) to make a write position available.

\pnum

\recommended

An implementation should consider \tcode{alsize} in making the

decision how many additional write positions to make available.

\end{itemdescr}

\indexlibrarymember{pbackfail}{strstreambuf}%

\begin{itemdecl}

int_type pbackfail(int_type c = EOF) override;

\end{itemdecl}

\begin{itemdescr}

\pnum

Puts back the character designated by \tcode{c} to the input

sequence, if possible, in one of three ways:

\begin{itemize}

\item

If

\tcode{c != EOF},

if the input sequence has a putback position available, and if

\tcode{(char)c == gnext[-1]},

assigns

\tcode{gnext - 1}

to \tcode{gnext}.

Returns \tcode{c}.

\item

If

\tcode{c != EOF},

if the input sequence has a putback position available, and if

\tcode{strmode \& constant} is zero,

assigns \tcode{c} to

\tcode{*--gnext}.

Returns

\tcode{c}.

\item

If

\tcode{c == EOF}

and if the input sequence has a putback position available,

assigns

\tcode{gnext - 1}

to \tcode{gnext}.

Returns a value other than

\tcode{EOF}.

\end{itemize}

\pnum

Returns

\tcode{EOF}

to indicate failure.

\pnum

\remarks

If the function can succeed in more than one of these ways, it is

unspecified which way is chosen.

\indextext{unspecified}%

The function can alter the number of putback

positions available as a result of any call.

\end{itemdescr}

\indexlibrarymember{underflow}{strstreambuf}%

\begin{itemdecl}

int_type underflow() override;

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Reads a character from the

\term{input sequence},

if possible, without moving the stream position past it, as follows:

\begin{itemize}

\item

If the input sequence has a read position available, the function

signals success by returning

\tcode{(unsigned char)\brk*gnext}.

\item

Otherwise, if

the current write next pointer \tcode{pnext} is not a null pointer and

is greater than the current read end pointer \tcode{gend},

makes a

\term{read position}

available by

assigning to \tcode{gend} a value greater than \tcode{gnext} and

no greater than \tcode{pnext}.

Returns \tcode{(unsigned char)*gnext}.

\end{itemize}

\pnum

Returns

\tcode{EOF}

to indicate failure.

\pnum

\remarks

The function can alter the number of read positions available as a

result of any call.

\end{itemdescr}

\indexlibrarymember{seekoff}{strstreambuf}%

\begin{itemdecl}

pos_type seekoff(off_type off, seekdir way, openmode which = in | out) override;

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Alters the stream position within one of the

controlled sequences, if possible, as indicated in \tref{depr.strstreambuf.seekoff.pos}.

\begin{libtab2}{\tcode{seekoff} positioning}{depr.strstreambuf.seekoff.pos}

{p{2.5in}l}{Conditions}{Result}

\tcode{(which \& ios::in) != 0} &

positions the input sequence \\ \rowsep

\tcode{(which \& ios::out) != 0} &

positions the output sequence \\ \rowsep

\tcode{(which \& (ios::in | ios::out)) ==}\br

\tcode{(ios::in | ios::out)} and either\br

\tcode{way == ios::beg} or \tcode{way == ios::end} &

positions both the input and the output sequences \\ \rowsep

Otherwise &

the positioning operation fails. \\

\end{libtab2}

\pnum

For a sequence to be positioned, if its next pointer is a null pointer,

the positioning operation fails.

Otherwise, the function determines \tcode{newoff} as indicated in

\tref{depr.strstreambuf.seekoff.newoff}.

\begin{libtab2}{\tcode{newoff} values}{depr.strstreambuf.seekoff.newoff}

{p{2.0in}p{2.0in}}{Condition}{\tcode{newoff} Value}

\tcode{way == ios::beg} &

0 \\ \rowsep

\tcode{way == ios::cur} &

the next pointer minus the beginning pointer (\tcode{xnext - xbeg}). \\ \rowsep

\tcode{way == ios::end} &

\tcode{seekhigh} minus the beginning pointer (\tcode{seekhigh - xbeg}). \\

\end{libtab2}

\pnum

If \tcode{(newoff + off) < (seeklow - xbeg)}

or \tcode{(seekhigh - xbeg) < (newoff + off)},

the positioning operation fails.

Otherwise, the function assigns

\tcode{xbeg + newoff + off}

to the next pointer \tcode{xnext}.

\pnum

\returns

\tcode{pos_type(newoff)},

constructed from the resultant offset

\tcode{newoff} (of type

\tcode{off_type}),

that stores the resultant stream position, if possible.

If the positioning operation fails, or

if the constructed object cannot represent the resultant stream position,

the return value is

\tcode{pos_type(off_type(-1))}.

\end{itemdescr}

\indexlibrarymember{seekpos}{strstreambuf}%

\begin{itemdecl}

pos_type seekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out) override;

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Alters the stream position within one of the

controlled sequences, if possible, to correspond to the

stream position stored in \tcode{sp}

(as described below).

\begin{itemize}

\item

If

\tcode{(which \& ios::in) != 0},

positions the input sequence.

\item

If

\tcode{(which \& ios::out) != 0},

positions the output sequence.

\item

If the function positions neither sequence, the positioning operation fails.

\end{itemize}

\pnum

For a sequence to be positioned, if its next pointer is a null pointer,

the positioning operation fails.

Otherwise, the function determines \tcode{newoff} from

\tcode{sp.offset()}:

\begin{itemize}

\item

If \tcode{newoff} is an invalid stream position,

has a negative value, or

has a value greater than (\tcode{seekhigh - seeklow}),

the positioning operation fails

\item

Otherwise, the function

adds \tcode{newoff} to the beginning pointer \tcode{xbeg} and

stores the result in the next pointer \tcode{xnext}.

\end{itemize}

\pnum

\returns

\tcode{pos_type(newoff)},

constructed from the resultant offset \tcode{newoff}

(of type

\tcode{off_type}),

that stores the resultant stream position, if possible.

If the positioning operation fails, or

if the constructed object cannot represent the resultant stream position,

the return value is

\tcode{pos_type(off_type(-1))}.

\end{itemdescr}

\indexlibrarymember{setbuf}{strstreambuf}%

\begin{itemdecl}

streambuf<char>* setbuf(char* s, streamsize n) override;

\end{itemdecl}

\begin{itemdescr}

\pnum

\effects

Behavior is \impldef{behavior of \tcode{strstreambuf::setbuf}},

except that

\tcode{setbuf(0, 0)}

has no effect.%

\end{itemdescr}

\rSec2[depr.istrstream]{Class \tcode{istrstream}}

\rSec3[depr.istrstream.general]{General}

\indexlibraryglobal{istrstream}%

\begin{codeblock}

namespace std {

class istrstream : public basic_istream<char> {

public:

explicit istrstream(const char* s);

explicit istrstream(char* s);

istrstream(const char* s, streamsize n);