30 Input/output library [input.output]

30.7 Formatting and manipulators [iostream.format]

30.7.1 Header <istream> synopsis [istream.syn]

namespace std {
  template <class charT, class traits = char_traits<charT>>
    class basic_istream;

  using istream  = basic_istream<char>;
  using wistream = basic_istream<wchar_t>;

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

  using iostream  = basic_iostream<char>;
  using wiostream = basic_iostream<wchar_t>;

  template <class charT, class traits>
    basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);

  template <class charT, class traits, class T>
    basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&& is, T&& x);
}

30.7.2 Header <ostream> synopsis [ostream.syn]

namespace std {
  template <class charT, class traits = char_traits<charT>>
    class basic_ostream;

  using ostream  = basic_ostream<char>;
  using wostream = basic_ostream<wchar_t>;

  template <class charT, class traits>
    basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);
  template <class charT, class traits>
    basic_ostream<charT, traits>& ends(basic_ostream<charT, traits>& os);
  template <class charT, class traits>
    basic_ostream<charT, traits>& flush(basic_ostream<charT, traits>& os);

  template <class charT, class traits, class T>
    basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&& os, const T& x);
}

30.7.3 Header <iomanip> synopsis [iomanip.syn]

namespace std {
  // types T1, T2, ... are unspecified implementation types
  T1 resetiosflags(ios_base::fmtflags mask);
  T2 setiosflags  (ios_base::fmtflags mask);
  T3 setbase(int base);
  template<charT> T4 setfill(charT c);
  T5 setprecision(int n);
  T6 setw(int n);
  template <class moneyT> T7 get_money(moneyT& mon, bool intl = false);
  template <class moneyT> T8 put_money(const moneyT& mon, bool intl = false);
  template <class charT> T9 get_time(struct tm* tmb, const charT* fmt);
  template <class charT> T10 put_time(const struct tm* tmb, const charT* fmt);

  template <class charT>
    T11 quoted(const charT* s, charT delim = charT('"'), charT escape = charT('\\'));

  template <class charT, class traits, class Allocator>
    T12 quoted(const basic_string<charT, traits, Allocator>& s,
               charT delim = charT('"'), charT escape = charT('\\'));

  template <class charT, class traits, class Allocator>
    T13 quoted(basic_string<charT, traits, Allocator>& s,
               charT delim = charT('"'), charT escape = charT('\\'));

  template <class charT, class traits>
    T14 quoted(basic_string_view<charT, traits> s,
               charT delim = charT('"'), charT escape = charT('\\'));
}

30.7.4 Input streams [input.streams]

Заголовок <istream> определяет два типа и сигнатуру функции, которая управляет вводом из буфера потока, а также шаблон функции, который извлекает из потока rvalue.

30.7.4.1 Class template basic_­istream [istream]

namespace std {
  template <class charT, class traits = char_traits<charT>>
  class basic_istream : virtual public basic_ios<charT, traits> {
  public:
    // types (inherited from basic_­ios):
    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;

    // [istream.cons], constructor/destructor
    explicit basic_istream(basic_streambuf<charT, traits>* sb);
    virtual ~basic_istream();

    // [istream::sentry], prefix/suffix
    class sentry;

    // [istream.formatted], formatted input
    basic_istream<charT, traits>&
      operator>>(basic_istream<charT, traits>& (*pf)(basic_istream<charT, traits>&));
    basic_istream<charT, traits>&
      operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
    basic_istream<charT, traits>&
      operator>>(ios_base& (*pf)(ios_base&));

    basic_istream<charT, traits>& operator>>(bool& n);
    basic_istream<charT, traits>& operator>>(short& n);
    basic_istream<charT, traits>& operator>>(unsigned short& n);
    basic_istream<charT, traits>& operator>>(int& n);
    basic_istream<charT, traits>& operator>>(unsigned int& n);
    basic_istream<charT, traits>& operator>>(long& n);
    basic_istream<charT, traits>& operator>>(unsigned long& n);
    basic_istream<charT, traits>& operator>>(long long& n);
    basic_istream<charT, traits>& operator>>(unsigned long long& n);
    basic_istream<charT, traits>& operator>>(float& f);
    basic_istream<charT, traits>& operator>>(double& f);
    basic_istream<charT, traits>& operator>>(long double& f);

    basic_istream<charT, traits>& operator>>(void*& p);
    basic_istream<charT, traits>& operator>>(basic_streambuf<char_type, traits>* sb);

    // [istream.unformatted], unformatted input
    streamsize gcount() const;
    int_type get();
    basic_istream<charT, traits>& get(char_type& c);
    basic_istream<charT, traits>& get(char_type* s, streamsize n);
    basic_istream<charT, traits>& get(char_type* s, streamsize n, char_type delim);
    basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
    basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb, char_type delim);

    basic_istream<charT, traits>& getline(char_type* s, streamsize n);
    basic_istream<charT, traits>& getline(char_type* s, streamsize n, char_type delim);

    basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::eof());
    int_type                      peek();
    basic_istream<charT, traits>& read    (char_type* s, streamsize n);
    streamsize                    readsome(char_type* s, streamsize n);

    basic_istream<charT, traits>& putback(char_type c);
    basic_istream<charT, traits>& unget();
    int sync();

    pos_type tellg();
    basic_istream<charT, traits>& seekg(pos_type);
    basic_istream<charT, traits>& seekg(off_type, ios_base::seekdir);

  protected:
    // [istream.cons], copy/move constructor
    basic_istream(const basic_istream& rhs) = delete;
    basic_istream(basic_istream&& rhs);

    // [istream.assign], assign and swap
    basic_istream& operator=(const basic_istream& rhs) = delete;
    basic_istream& operator=(basic_istream&& rhs);
    void swap(basic_istream& rhs);
  };

  // [istream.extractors], character extraction templates
  template<class charT, class traits>
    basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&, charT&);
  template<class traits>
    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, unsigned char&);
  template<class traits>
    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, signed char&);

  template<class charT, class traits>
    basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&, charT*);
  template<class traits>
    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, unsigned char*);
  template<class traits>
    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, signed char*);
}

Шаблон класса basic_­istream определяет ряд сигнатур функций-членов, которые помогают читать и интерпретировать ввод из последовательностей, управляемых буфером потока.

Две группы сигнатур функций-членов имеют общие свойства: formatted input functions (или extractors) и unformatted input functions. Обе группы функций ввода описываются так, как если бы они получали (или extract) ввод с characters помощью вызова rdbuf()->sbumpc() или rdbuf()->sgetc(). Они могут использовать других публичных членов istream.

Если rdbuf()->sbumpc() или rdbuf()->sgetc() возвращает traits​::​eof(), то функция ввода, если явно не указано иное, завершает свои действия и выполняет setstate(eofbit), что может вызвать throw ios_­base​::​failure ([iostate.flags]), перед возвратом.

Если одна из этих вызываемых функций вызывает исключение, то, если явно не указано иное, функция ввода переходит badbit в состояние ошибки. Если badbit он exceptions()включен, функция ввода повторно генерирует исключение, не завершая своих действий, в противном случае она ничего не генерирует и продолжает работу, как если бы вызываемая функция вернула индикацию сбоя.

30.7.4.1.1 basic_­istream constructors [istream.cons]

explicit basic_istream(basic_streambuf<charT, traits>* sb);

Effects: Создает объект класса basic_­istream, инициализируя подобъект базового класса с помощью basic_­ios​::​init(sb) ([basic.ios.cons]).

Postconditions: gcount() == 0.

basic_istream(basic_istream&& rhs);

Effects: Переместите конструкции из rvalue rhs. Это выполняется по умолчанию путем создания базового класса, копирования gcount() из rhs, вызова basic_­ios<charT, traits>​::​move(rhs) для инициализации базового класса и установки gcount() for rhs в 0.

virtual ~basic_istream();

Effects: Уничтожает объект класса basic_­istream.

Remarks: Не выполняет никаких операций rdbuf().

30.7.4.1.2 Class basic_­istream assign and swap [istream.assign]

basic_istream& operator=(basic_istream&& rhs);

Effects: Как будто мимо swap(rhs).

Returns: *this.

void swap(basic_istream& rhs);

Effects: Звонки basic_­ios<charT, traits>​::​swap(rhs). Меняет значения, возвращаемые gcount() и rhs.gcount().

30.7.4.1.3 Class basic_­istream​::​sentry [istream::sentry]

namespace std {
  template <class charT, class traits = char_traits<charT>>
  class basic_istream<charT, traits>::sentry {
    using traits_type = traits;
    bool ok_; // exposition only
  public:
    explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);
    ~sentry();
    explicit operator bool() const { return ok_; }
    sentry(const sentry&) = delete;
    sentry& operator=(const sentry&) = delete;
  };
}

Этот класс sentry определяет класс, который отвечает за выполнение безопасных в отношении исключений операций с префиксом и суффиксом.

explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);

Effects: Если is.good() есть false, звонит is.setstate(failbit). В противном случае готовится к форматированному или неформатированному вводу. Во-первых, если is.tie() это не нулевой указатель, функция вызывает is.tie()->flush() синхронизацию выходной последовательности с любым связанным внешним потоком C. За исключением того, что этот вызов может быть подавлен, если область размещения is.tie() пуста. Кроме того, реализации разрешается отложить вызов до flush тех пор, пока неis.rdbuf()->underflow() произойдет вызов . Если такой вызов не происходит до того, как sentry объект будет уничтожен, вызов flush может быть полностью исключен.305 Если noskipws равен нулю и is.flags() & ios_­base​::​skipws отличен от нуля, функция извлекает и отбрасывает каждый символ до тех пор, пока следующий доступный входной символ c является пробельным символом. Если is.rdbuf()->sbumpc() или is.rdbuf()->sgetc() возвращается traits​::​eof(), функция вызывает setstate(failbit | eofbit) (который может бросить ios_­base​::​failure).

Remarks: Конструктор

explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false)

использует текущий встроенный языковой стандарт в is, чтобы определить, является ли следующий входной символ пробелом или нет.

Чтобы определить, является ли данный символ c пробельным символом, конструктор работает так, как если бы он выполнял следующий фрагмент кода:

const ctype<charT>& ctype = use_facet<ctype<charT>>(is.getloc());
if (ctype.is(ctype.space, c) != 0)
  // c is a whitespace character.

Если после любой препарат будет завершен, is.good() это true, вok_­ != false противном случае ok_­ == false. Во время подготовки конструктор может вызвать setstate(failbit) (который может throw ios_­base​::​​failure ([iostate.flags]))306

~sentry();

Effects: Никто.

explicit operator bool() const;

Effects: Возврат ok_­.

Это будет возможно только в функциях, которые являются частью библиотеки. Семантика конструктора, используемого в пользовательском коде, указана.

Конструктор и деструктор сторожа также могут выполнять дополнительные операции, зависящие от реализации.

30.7.4.2 Formatted input functions [istream.formatted]

30.7.4.2.1 Common requirements [istream.formatted.reqmts]

Каждая функция форматированного ввода начинает выполнение с создания объекта класса sentry с noskipws (вторым) аргументом false. Если sentry объект возвращается trueпри преобразовании в значение типа bool, функция пытается получить запрошенный ввод. Если во время ввода возникает исключение, то ios​::​badbit он включается307 в *thisсостоянии ошибки. Если (exceptions()&badbit) != 0 тогда исключение генерируется повторно. В любом случае функция форматированного ввода уничтожает sentry объект. Если исключение не было создано, оно возвращается *this.

Это делается без ios​::​failure броска.

30.7.4.2.2 Arithmetic extractors [istream.formatted.arithmetic]

operator>>(unsigned short& val); operator>>(unsigned int& val); operator>>(long& val); operator>>(unsigned long& val); operator>>(long long& val); operator>>(unsigned long long& val); operator>>(float& val); operator>>(double& val); operator>>(long double& val); operator>>(bool& val); operator>>(void*& val);

Как и в случае со средствами вставки, эти экстракторы зависят отnum_­get<> объекта локали для выполнения синтаксического анализа данных входного потока. Эти экстракторы действуют как функции форматированного ввода (как описано в разделе [istream.formatted.reqmts]). После создания объекта-часового преобразование происходит так, как если бы оно выполнялось следующим фрагментом кода:

using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
iostate err = iostate::goodbit;
use_facet<numget>(loc).get(*this, 0, *this, err, val);
setstate(err);

В приведенном выше фрагменте loc это закрытый член basic_­ios класса. [ Note: Первый аргумент предоставляет объект istreambuf_­iterator класса, который является итератором, указывающим на входной поток. Он обходит istreams и напрямую использует streambufs. ] Класс полагается на этот тип как на свой интерфейс , поэтому нет необходимости напрямую зависеть от него . end notelocaleistreamistream

operator>>(short& val);

Преобразование происходит так, как если бы оно было выполнено следующим фрагментом кода (с использованием тех же обозначений, что и для предыдущего фрагмента кода):

using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
iostate err = ios_base::goodbit;
long lval;
use_facet<numget>(loc).get(*this, 0, *this, err, lval);
if (lval < numeric_limits<short>::min()) {
  err |= ios_base::failbit;
  val = numeric_limits<short>::min();
} else if (numeric_limits<short>::max() < lval) {
  err |= ios_base::failbit;
  val = numeric_limits<short>::max();
}  else
  val = static_cast<short>(lval);
setstate(err);

operator>>(int& val);

Преобразование происходит так, как если бы оно было выполнено следующим фрагментом кода (с использованием тех же обозначений, что и для предыдущего фрагмента кода):

using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
iostate err = ios_base::goodbit;
long lval;
use_facet<numget>(loc).get(*this, 0, *this, err, lval);
if (lval < numeric_limits<int>::min()) {
  err |= ios_base::failbit;
  val = numeric_limits<int>::min();
} else if (numeric_limits<int>::max() < lval) {
  err |= ios_base::failbit;
  val = numeric_limits<int>::max();
}  else
  val = static_cast<int>(lval);
setstate(err);

30.7.4.2.3 basic_­istream​::​operator>> [istream.extractors]

basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& (*pf)(basic_istream<charT, traits>&));

Effects: Никто. Этот экстрактор не ведет себя как функция форматированного ввода (как описано в [istream.formatted.reqmts]).

Returns: pf(*this).308

basic_istream<charT, traits>& operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));

Effects: Звонки pf(*this). Этот экстрактор не ведет себя как функция форматированного ввода (как описано в [istream.formatted.reqmts]).

Returns: *this.

basic_istream<charT, traits>& operator>>(ios_base& (*pf)(ios_base&));

Effects: Звонки pf(*this).309 Этот экстрактор не ведет себя как функция форматированного ввода (как описано в [istream.formatted.reqmts]).

Returns: *this.

template<class charT, class traits> basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& in, charT* s); template<class traits> basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, unsigned char* s); template<class traits> basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char* s);

Effects: Ведет себя как отформатированный входной член (как описано в [istream.formatted.reqmts]) of in. После создания sentry объекта operator>> извлекает символы и сохраняет их в последовательных местах массива, первый элемент которого обозначен знаком s. Если width() больше нуля, то n есть width(). В противном случае n - это количество элементов самого большого массива, в char_­type котором может храниться завершение charT(). n - максимальное количество хранимых символов.

Символы извлекаются и сохраняются до тех пор, пока не произойдет одно из следующих событий:

  • n-1 символы сохраняются;

  • конец файла происходит во входной последовательности;

  • пусть ct будет use_­facet<ctype<charT>>(in.getloc()), ct.is(ct.space, c) есть true.

operator>> затем сохраняет нулевой байт (charT()) в следующей позиции, которая может быть первой позицией, если символы не были извлечены. operator>> потом звонит width(0).

Если функция не извлекла никаких символов, она вызывает setstate(failbit), что может вызвать throw ios_­base​::​​failure ([iostate.flags]).

Returns: in.

template<class charT, class traits> basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& in, charT& c); template<class traits> basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, unsigned char& c); template<class traits> basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char& c);

Effects: Ведет себя как отформатированный входной член (как описано в [istream.formatted.reqmts]) of in. После создания sentry объекта из него извлекается символ in, если он доступен, и сохраняется в c. В противном случае функция вызывает in.setstate(failbit).

Returns: in.

basic_istream<charT, traits>& operator>>(basic_streambuf<charT, traits>* sb);

Effects: Ведет себя как unformatted input function. Если sb равно нулю, вызывает setstate(failbit), который может throw ios_­base​::​failure ([iostate.flags]). После того, как часовой объект построен, извлекает символы из *this и вставляет их в выходную последовательность, управляемую sb. Символы извлекаются и вставляются до тех пор, пока не произойдет одно из следующих событий:

  • конец файла встречается во входной последовательности;

  • вставка в выходную последовательность не выполняется (в этом случае вставляемый символ не извлекается);

  • возникает исключение (в этом случае исключение перехватывается).

Если функция не вставляет символы, она вызывает setstate(failbit), что может вызвать throw ios_­base​::​​failure ([iostate.flags]). Если он не вставил никаких символов, потому что он поймал исключение, созданное при извлечении символов из *this и включеноfailbit в exceptions() ([iostate.flags]), то пойманное исключение генерируется повторно.

Returns: *this.

См., Например, сигнатуру функции ws(basic_­istream&).

См., Например, сигнатуру функции dec(ios_­base&).

30.7.4.3 Unformatted input functions [istream.unformatted]

Каждая неформатированная функция ввода начинает выполнение с создания объекта класса sentry с аргументом по умолчанию noskipws (вторым) аргументом true. Если sentry объект возвращается trueпри преобразовании в значение типа bool, функция пытается получить запрошенный ввод. В противном случае, если конструктор часового выходит, генерируя исключение, или если объект часового возвращается false, при преобразовании в значение типа boolфункция возвращается, не пытаясь получить какие-либо входные данные. В любом случае количество извлеченных символов равно 0; неформатированные входные функции, принимающие в качестве аргумента массив символов ненулевого размера, также должны сохранять нулевой символ (использование charT()) в первом месте массива. Если во время ввода возникает исключение, то ios​::​badbit он включается310 в *thisсостоянии ошибки. (basic_­ios<>​::​clear() Выброшенные исключения не перехватываются и не генерируются повторно.) Если (exceptions()&badbit) != 0 тогда исключение генерируется повторно. Он также считает количество извлеченных символов. Если исключение не было создано, оно заканчивается сохранением счетчика в объекте-члене и возвратом указанного значения. В любом случае sentry объект уничтожается до выхода из неформатированной функции ввода.

streamsize gcount() const;

Effects: Никто. Эта функция-член не ведет себя как неформатированная функция ввода (как описано выше).

Returns: Число символов, извлеченных последней неформатированной входной функцией-членом, вызванной для объекта.

int_type get();

Effects: Ведет себя как неформатированная функция ввода (как описано выше). После создания сторожевого объекта извлекает персонажа c, если он доступен. В противном случае вызовы функции setstate(failbit), которая может throw ios_­base​::​failure ([iostate.flags]),

Returns: c если доступно, в противном случае traits​::​eof().

basic_istream<charT, traits>& get(char_type& c);

Effects: Ведет себя как неформатированная функция ввода (как описано выше). После создания сторожевого объекта извлекает персонажа, если он доступен, и назначает его c.311 В противном случае вызывается функция setstate(failbit) (которая может throw ios_­base​::​failure ([iostate.flags])).

Returns: *this.

basic_istream<charT, traits>& get(char_type* s, streamsize n, char_type delim);

Effects: Ведет себя как неформатированная функция ввода (как описано выше). После создания сторожевого объекта извлекает символы и сохраняет их в последовательных местах массива, первый элемент которого обозначен знаком s.312 Символы извлекаются и сохраняются до тех пор, пока не произойдет одно из следующих событий:

  • n меньше единицы или n - 1 символы сохраняются;

  • конец файла происходит во входной последовательности (в этом случае функция вызывает setstate(eofbit));

  • traits​::​eq(c, delim) для следующего доступного входного символа c (в этом случае c не извлекается).

Если функция не хранит символы, она вызывает setstate(failbit) (что может вызвать throw ios_­base​::​​failure ([iostate.flags])). В любом случае, если n он больше нуля, он сохраняет нулевой символ в следующем последовательном месте массива.

Returns: *this.

basic_istream<charT, traits>& get(char_type* s, streamsize n);

Effects: Звонки get(s, n, widen('\n')).

Returns: Значение, возвращаемое вызовом.

basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb, char_type delim);

Effects: Ведет себя как неформатированная функция ввода (как описано выше). После создания сторожевого объекта извлекает символы и вставляет их в выходную последовательность, управляемую sb. Символы извлекаются и вставляются до тех пор, пока не произойдет одно из следующих событий:

  • конец файла встречается во входной последовательности;

  • вставка в выходную последовательность не выполняется (в этом случае вставляемый символ не извлекается);

  • traits​::​eq(c, delim) для следующего доступного входного символа c (в этом случае c не извлекается);

  • возникает исключение (в этом случае исключение перехватывается, но не генерируется повторно).

Если функция не вставляет символы, она вызывает setstate(failbit), что может вызвать throw ios_­base​::​​failure ([iostate.flags]).

Returns: *this.

basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);

Effects: Звонки get(sb, widen('\n')).

Returns: Значение, возвращаемое вызовом.

basic_istream<charT, traits>& getline(char_type* s, streamsize n, char_type delim);

Effects: Ведет себя как неформатированная функция ввода (как описано выше). После создания сторожевого объекта извлекает символы и сохраняет их в последовательных местах массива, первый элемент которого обозначен знаком s.313 Символы извлекаются и сохраняются до тех пор, пока не произойдет одно из следующих событий:

  1. 1.конец файла происходит во входной последовательности (в этом случае функция вызывает setstate(eofbit));

  2. 2.traits​::​eq(c, delim) для следующего доступного входного символа c (в этом случае входной символ извлекается, но не сохраняется);314

  3. 3.n меньше единицы или n - 1 символы сохраняются (в этом случае функция вызывает setstate(​failbit)).

Эти условия проверяются в указанном порядке.315

Если функция не извлекает символы, она вызывает setstate(failbit) (что может вызвать throw ios_­base​::​​failure ([iostate.flags])).316

В любом случае, если n он больше нуля, он затем сохраняет нулевой символ (использование charT()) в следующем последовательном месте массива.

Returns: *this.

[Example:

#include <iostream>

int main() {
  using namespace std;
  const int line_buffer_size = 100;

  char buffer[line_buffer_size];
  int line_number = 0;
  while (cin.getline(buffer, line_buffer_size, '\n') || cin.gcount()) {
    int count = cin.gcount();
    if (cin.eof())
      cout << "Partial final line";   // cin.fail() is false
    else if (cin.fail()) {
      cout << "Partial long line";
      cin.clear(cin.rdstate() & ~ios_base::failbit);
    } else {
      count--;                        // Don't include newline in count
      cout << "Line " << ++line_number;
    }
    cout << " (" << count << " chars): " << buffer << endl;
  }
}

end example]

basic_istream<charT, traits>& getline(char_type* s, streamsize n);

Returns: getline(s, n, widen('\n'))

basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::eof());

Effects: Ведет себя как неформатированная функция ввода (как описано выше). После создания объекта-часового извлекает персонажей и отбрасывает их. Символы извлекаются до тех пор, пока не произойдет одно из следующих событий:

  • n != numeric_­limits<streamsize>​::​max() и n персонажи были извлечены до сих пор

  • конец файла происходит во входной последовательности (в этом случае вызывается функция setstate(eofbit), которая может throw ios_­base​::​failure ([iostate.flags]));

  • traits​::​eq_­int_­type(traits​::​to_­int_­type(c), delim) для следующего доступного входного символа c (в этом случае c извлекается).

Remarks: Последнее условие никогда не произойдет, если traits​::​eq_­int_­type(delim, traits​::​eof()).

Returns: *this.

int_type peek();

Effects: Ведет себя как неформатированная функция ввода (как описано выше). После создания сторожевого объекта считывает, но не извлекает текущий входной символ.

Returns: traits​::​eof() если good() есть false. В противном случае возвращается rdbuf()->sgetc().

basic_istream<charT, traits>& read(char_type* s, streamsize n);

Effects: Ведет себя как неформатированная функция ввода (как описано выше). После создания сторожевого объекта, если !good() вызовы, setstate(failbit) которые могут вызвать исключение, и возврат. В противном случае извлекает символы и сохраняет их в последовательных местах массива, первый элемент которого обозначен знаком s.317 Символы извлекаются и сохраняются до тех пор, пока не произойдет одно из следующих событий:

  • n символы сохраняются;

  • конец файла происходит во входной последовательности (в этом случае вызывается функция setstate(failbit | eofbit), которая может throw ios_­base​::​failure ([iostate.flags])).

Returns: *this.

streamsize readsome(char_type* s, streamsize n);

Effects: Ведет себя как неформатированная функция ввода (как описано выше). После создания сторожевого объекта, если !good() вызовы, setstate(failbit) которые могут вызвать исключение, и возврат. В противном случае извлекает символы и сохраняет их в последовательных местах массива, первый элемент которого обозначен знаком s. Если rdbuf()->in_­avail() == -1, вызывает setstate(eofbit) (который может throw ios_­base​::​failure ([iostate.flags])) и не извлекает символы;

  • Если rdbuf()->in_­avail() == 0, не извлекает символы

  • Если rdbuf()->in_­avail() > 0, извлекает min(rdbuf()->in_­avail(), n)).

Returns: Количество извлеченных символов.

basic_istream<charT, traits>& putback(char_type c);

Effects: Ведет себя как неформатированная функция ввода (как описано выше), за исключением того, что функция сначала очищается eofbit. После создания сторожевого объекта, если !good() вызовы, setstate(failbit) которые могут вызвать исключение, и возврат. Если rdbuf() не равно нулю, вызывает rdbuf->sputbackc(). Если rdbuf() имеет значение null, или если sputbackc() возвращается traits​::​eof(), вызывает setstate(badbit) (который может throw ios_­base​::​failure ([iostate.flags])). [ Note: Эта функция не извлекает символы, поэтому при следующем вызове возвращается значение gcount() 0. ]end note

Returns: *this.

basic_istream<charT, traits>& unget();

Effects: Ведет себя как неформатированная функция ввода (как описано выше), за исключением того, что функция сначала очищается eofbit. После создания сторожевого объекта, если !good() вызовы, setstate(failbit) которые могут вызвать исключение, и возврат. Если rdbuf() не равно нулю, вызывает rdbuf()->sungetc(). Если rdbuf() имеет значение null, или если sungetc() возвращается traits​::​eof(), вызывает setstate(badbit) (который может throw ios_­base​::​failure ([iostate.flags])). [ Note: Эта функция не извлекает символы, поэтому при следующем вызове возвращается значение gcount() 0. ]end note

Returns: *this.

int sync();

Effects: Ведет себя как неформатированная функция ввода (как описано выше), за исключением того, что она не подсчитывает количество извлеченных символов и не влияет на значение, возвращаемое последующими вызовами gcount(). После создания сторожевого объекта rdbuf() возвращается пустой указатель -1. В противном случае вызывает rdbuf()->pubsync() и, если эта функция возвращает -1 вызовы setstate(badbit) (которые могут вызывать throw ios_­base​::​failure ([iostate.flags]), и возвращает -1. В противном случае возвращает ноль.

pos_type tellg();

Effects: Ведет себя как неформатированная функция ввода (как описано выше), за исключением того, что она не подсчитывает количество извлеченных символов и не влияет на значение, возвращаемое последующими вызовами gcount().

Returns: После создания сторожевого объекта, если fail() != false, возвращается, pos_­type(-1) чтобы указать на сбой. В противном случае возвращается rdbuf()->pubseekoff(0, cur, in).

basic_istream<charT, traits>& seekg(pos_type pos);

Effects: Ведет себя как неформатированная функция ввода (как описано выше), за исключением того, что функция сначала очищает eofbit, она не подсчитывает количество извлеченных символов и не влияет на значение, возвращаемое последующими вызовами gcount(). После создания сторожевого объекта if fail() != trueвыполняется rdbuf()->pubseekpos(pos, ios_­base​::​in). В случае неудачи вызовы функции setstate(failbit) (которые могут выкинуть ios_­base​::​failure).

Returns: *this.

basic_istream<charT, traits>& seekg(off_type off, ios_base::seekdir dir);

Effects: Ведет себя как неформатированная функция ввода (как описано выше), за исключением того, что функция сначала очищает eofbit, не подсчитывает количество извлеченных символов и не влияет на значение, возвращаемое последующими вызовами gcount(). После создания сторожевого объекта if fail() != trueвыполняется rdbuf()->pubseekoff(off, dir, ios_­base​::​in). В случае неудачи вызовы функции setstate(​failbit) (которые могут выкинуть ios_­base​::​failure).

Returns: *this.

Это делается без ios​::​failure броска.

Обратите внимание, что эта функция не перегружена для типов signed char и unsigned char.

Обратите внимание, что эта функция не перегружена для типов signed char и unsigned char.

Обратите внимание, что эта функция не перегружена для типов signed char и unsigned char.

Поскольку последний входной символ «извлекается», он засчитывается в gcount(), даже если он не сохраняется.

Это позволяет вводной строке, которая точно заполняет буфер, без настройки failbit. Это отличается от исторической реализации AT&T.

Это означает, что пустая строка ввода не failbit требует установки.

Обратите внимание, что эта функция не перегружена для типов signed char и unsigned char.

30.7.4.4 Standard basic_­istream manipulators [istream.manip]

template <class charT, class traits> basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);

Effects: Ведет себя как an unformatted input function, за исключением того, что он не считает количество извлеченных символов и не влияет на значение, возвращаемое последующими вызовами is.gcount (). После создания сторожевой объект извлекает символы до тех пор, пока следующий доступный символ c является пробелом, или до тех пор, пока в последовательности не останется символов. Пробельные символы различаются по тому же критерию, что и символы sentry​::​sentry. Если ws прекращает извлечение символов, потому что их больше нет, он устанавливает eofbit, но не failbit.

Returns: is.

30.7.4.5 Rvalue stream extraction [istream.rvalue]

template <class charT, class traits, class T> basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&& is, T&& x);

Effects: Эквивалентен:

is >> std::forward<T>(x);
return is;

Remarks: Эта функция не должна участвовать в разрешении перегрузки, если выражение is >> std​::​forward<T>(x) не сформировано правильно.

30.7.4.6 Class template basic_­iostream [iostreamclass]

namespace std {
  template <class charT, class traits = char_traits<charT>>
  class basic_iostream
    : public basic_istream<charT, traits>,
      public basic_ostream<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;

    // [iostream.cons], constructor
    explicit basic_iostream(basic_streambuf<charT, traits>* sb);

    // [iostream.dest], destructor
    virtual ~basic_iostream();

  protected:
    // [iostream.cons], constructor
    basic_iostream(const basic_iostream& rhs) = delete;
    basic_iostream(basic_iostream&& rhs);

    // [iostream.assign], assign and swap
    basic_iostream& operator=(const basic_iostream& rhs) = delete;
    basic_iostream& operator=(basic_iostream&& rhs);
    void swap(basic_iostream& rhs);
  };
}

Шаблон класса basic_­iostream наследует ряд функций, которые позволяют читать ввод и записывать вывод в последовательности, управляемые буфером потока.

30.7.4.6.1 basic_­iostream constructors [iostream.cons]

explicit basic_iostream(basic_streambuf<charT, traits>* sb);

Effects: Создает объект класса basic_­iostream, инициализируя подобъекты базового класса с помощью basic_­istream<charT, traits>(sb) и basic_­ostream<charT, traits>(sb).

Postconditions: rdbuf() == sb и gcount() == 0.

basic_iostream(basic_iostream&& rhs);

Effects: Перемещение конструкций из RValue rhs путем построения basic_­istream базового класса с move(rhs).

30.7.4.6.2 basic_­iostream destructor [iostream.dest]

virtual ~basic_iostream();

Effects: Уничтожает объект класса basic_­iostream.

Remarks: Не выполняет никаких операций над rdbuf().

30.7.4.6.3 basic_­iostream assign and swap [iostream.assign]

basic_iostream& operator=(basic_iostream&& rhs);

Effects: Как будто мимо swap(rhs).

void swap(basic_iostream& rhs);

Effects: Звонки basic_­istream<charT, traits>​::​swap(rhs).

30.7.5 Output streams [output.streams]

Заголовок <ostream> определяет тип и несколько сигнатур функций, которые управляют выводом в буфер потока вместе с шаблоном функции, который вставляется в rvalue потока.

30.7.5.1 Class template basic_­ostream [ostream]

namespace std {
  template <class charT, class traits = char_traits<charT>>
  class basic_ostream : virtual public basic_ios<charT, traits> {
  public:
    // types (inherited from basic_­ios):
    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;

    // [ostream.cons], constructor/destructor
    explicit basic_ostream(basic_streambuf<char_type, traits>* sb);
    virtual ~basic_ostream();

    // [ostream::sentry], prefix/suffix
    class sentry;

    // [ostream.formatted], formatted output
    basic_ostream<charT, traits>&
      operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>&));
    basic_ostream<charT, traits>&
      operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
    basic_ostream<charT, traits>&
      operator<<(ios_base& (*pf)(ios_base&));

    basic_ostream<charT, traits>& operator<<(bool n);
    basic_ostream<charT, traits>& operator<<(short n);
    basic_ostream<charT, traits>& operator<<(unsigned short n);
    basic_ostream<charT, traits>& operator<<(int n);
    basic_ostream<charT, traits>& operator<<(unsigned int n);
    basic_ostream<charT, traits>& operator<<(long n);
    basic_ostream<charT, traits>& operator<<(unsigned long n);
    basic_ostream<charT, traits>& operator<<(long long n);
    basic_ostream<charT, traits>& operator<<(unsigned long long n);
    basic_ostream<charT, traits>& operator<<(float f);
    basic_ostream<charT, traits>& operator<<(double f);
    basic_ostream<charT, traits>& operator<<(long double f);

    basic_ostream<charT, traits>& operator<<(const void* p);
    basic_ostream<charT, traits>& operator<<(nullptr_t);
    basic_ostream<charT, traits>& operator<<(basic_streambuf<char_type, traits>* sb);

    // [ostream.unformatted], unformatted output
    basic_ostream<charT, traits>& put(char_type c);
    basic_ostream<charT, traits>& write(const char_type* s, streamsize n);

    basic_ostream<charT, traits>& flush();

    // [ostream.seeks], seeks
    pos_type tellp();
    basic_ostream<charT, traits>& seekp(pos_type);
    basic_ostream<charT, traits>& seekp(off_type, ios_base::seekdir);

  protected:
    // [ostream.cons], copy/move constructor
    basic_ostream(const basic_ostream& rhs) = delete;
    basic_ostream(basic_ostream&& rhs);

    // [ostream.assign], assign and swap
    basic_ostream& operator=(const basic_ostream& rhs) = delete;
    basic_ostream& operator=(basic_ostream&& rhs);
    void swap(basic_ostream& rhs);
  };

  // [ostream.inserters.character], character inserters
  template<class charT, class traits>
    basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, charT);
  template<class charT, class traits>
    basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, char);
  template<class traits>
    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char);

  template<class traits>
    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, signed char);
  template<class traits>
    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, unsigned char);

  template<class charT, class traits>
    basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, const charT*);
  template<class charT, class traits>
    basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, const char*);
  template<class traits>
    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char*);

  template<class traits>
    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const signed char*);
  template<class traits>
    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const unsigned char*);
}

Шаблон класса basic_­ostream определяет ряд сигнатур функций-членов, которые помогают форматировать и записывать выходные данные в выходные последовательности, управляемые буфером потока.

Две группы сигнатур функций-членов имеют общие свойства: formatted output functions (или inserters) и unformatted output functions. Обе группы функций вывода генерируют (или insert) вывод characters посредством действий, эквивалентных вызову rdbuf()->sputc(int_­type). Они могут использовать другие общественные член заbasic_­ostream исключением того , что они не должны вызывать какие - либо виртуальные членов , заrdbuf() исключением overflow(), xsputn()и sync().

Если одна из этих вызываемых функций вызывает исключение, тогда, если явно не указано иное, функция вывода переходит badbit в состояние ошибки. Если badbit на в exceptions(), функции выхода rethrows исключения без завершения его действия, в противном случае он ничего и лечить как ошибку не бросать.

30.7.5.1.1 basic_­ostream constructors [ostream.cons]

explicit basic_ostream(basic_streambuf<charT, traits>* sb);

Effects: Создает объект класса basic_­ostream, инициализируя подобъект базового класса с помощью basic_­ios<charT, traits>​::​init(sb) ([basic.ios.cons]).

Postconditions: rdbuf() == sb.

basic_ostream(basic_ostream&& rhs);

Effects: Переместите конструкции из rvalue rhs. Это выполняется по умолчанию путем создания базового класса и вызова basic_­ios<charT, traits>​::​move(rhs) для инициализации базового класса.

virtual ~basic_ostream();

Effects: Уничтожает объект класса basic_­ostream.

Remarks: Не выполняет никаких операций над rdbuf().

30.7.5.1.2 Class basic_­ostream assign and swap [ostream.assign]

basic_ostream& operator=(basic_ostream&& rhs);

Effects: Как будто мимо swap(rhs).

Returns: *this.

void swap(basic_ostream& rhs);

Effects: Звонки basic_­ios<charT, traits>​::​swap(rhs).

30.7.5.1.3 Class basic_­ostream​::​sentry [ostream::sentry]

namespace std {
  template <class charT, class traits = char_traits<charT>>
  class basic_ostream<charT, traits>::sentry {
    bool ok_; // exposition only
  public:
    explicit sentry(basic_ostream<charT, traits>& os);
    ~sentry();
    explicit operator bool() const { return ok_; }

    sentry(const sentry&) = delete;
    sentry& operator=(const sentry&) = delete;
  };
}

Этот класс sentry определяет класс, который отвечает за выполнение безопасных в отношении исключений операций с префиксом и суффиксом.

explicit sentry(basic_ostream<charT, traits>& os);

Если не os.good() равно нулю, готовится к форматированному или неформатированному выводу. Если os.tie() не является нулевым указателем, вызывает os.tie()->flush().318

Если после любой препарат будет завершен, os.good() это true, вok_­ == true противном случае ok_­ == false. Во время подготовки конструктор может вызвать setstate(failbit) (который может throw ios_­base​::​​failure ([iostate.flags]))319

~sentry();

Если (os.flags() & ios_­base​::​unitbuf) && !uncaught_­exceptions() && os.good() есть true, звонит os.rdbuf()->pubsync(). Если эта функция возвращает -1, устанавливает badbit в os.rdstate() без распространяющегося исключения.

explicit operator bool() const;

Effects: Возврат ok_­.

Вызов os.tie()->flush() не обязательно происходит, если функция может определить, что синхронизация не требуется.

sentry Конструктор и деструктор может также выполнять дополнительные операции , зависящие от реализации.

30.7.5.1.4 basic_­ostream seek members [ostream.seeks]

Каждая функция-член поиска начинает выполнение с создания объекта класса sentry. Он возвращается, уничтожая sentry объект.

pos_type tellp();

Returns: Если fail() != false, возвращается, pos_­type(-1) чтобы указать на сбой. В противном случае возвращается rdbuf()->​pubseekoff(​0, cur, out).

basic_ostream<charT, traits>& seekp(pos_type pos);

Effects: Если fail() != trueвыполняется rdbuf()->pubseekpos(pos, ios_­base​::​out). В случае неудачи вызовы функции setstate(failbit) (которые могут выкинуть ios_­base​::​failure).

Returns: *this.

basic_ostream<charT, traits>& seekp(off_type off, ios_base::seekdir dir);

Effects: Если fail() != trueвыполняется rdbuf()->pubseekoff(off, dir, ios_­base​::​out). В случае неудачи вызовы функции setstate(failbit) (которые могут выкинуть ios_­base​::​failure).

Returns: *this.

30.7.5.2 Formatted output functions [ostream.formatted]

30.7.5.2.1 Common requirements [ostream.formatted.reqmts]

Каждая функция форматированного вывода начинает выполнение с создания объекта класса sentry. Если этот объект возвращается true при преобразовании в значение типа bool, функция пытается сгенерировать запрошенный вывод. В случае сбоя генерации выполняется функция форматированного вывода setstate(ios_­base​::​failbit), которая может вызвать исключение. Если во время вывода возникает исключение, то ios​::​badbit включается320 в *thisсостоянии ошибки. Если (exceptions()&badbit) != 0 тогда исключение генерируется повторно. Независимо от того, выбрасывается ли исключение, sentry объект уничтожается до выхода из функции форматированного вывода. Если исключение не генерируется, результатом функции форматированного вывода будет *this.

Описания отдельных функций форматированного вывода описывают, как они выполняют вывод, и не упоминают sentry объект.

Если функция форматированного вывода потока os определяет заполнение, это делается следующим образом. Для данной charT символьной последовательности, seq где charT - символьный тип потока, если длина seq меньше чем os.width(), тоos.fill() к этой последовательности добавляется достаточное количество копий, необходимое для заполнения до ширины os.width() символов. Если (os.flags() & ios_­base​::​adjustfield) == ios_­base​::​left есть true, символы заполнения помещаются после последовательности символов; в противном случае они помещаются перед последовательностью символов.

не вызывая ios​::​failure броска.

30.7.5.2.2 Arithmetic inserters [ostream.inserters.arithmetic]

operator<<(bool val); operator<<(short val); operator<<(unsigned short val); operator<<(int val); operator<<(unsigned int val); operator<<(long val); operator<<(unsigned long val); operator<<(long long val); operator<<(unsigned long long val); operator<<(float val); operator<<(double val); operator<<(long double val); operator<<(const void* val);

Effects: Классы num_­get<> и num_­put<> обрабатывают зависящее от языкового стандарта числовое форматирование и синтаксический анализ. Эти функции вставки используют встроенное locale значение для форматирования чисел. Когда val имеет тип bool, long, unsigned long, long long, unsigned long long, double, long double, или const void*, форматирование превращение происходит так , как будто он выполняется следующий фрагмент кода:

bool failed = use_facet<
  num_put<charT, ostreambuf_iterator<charT, traits>>
    >(getloc()).put(*this, *this, fill(), val).failed();

Когда val is of type, short преобразование форматирования происходит так, как если бы оно выполняло следующий фрагмент кода:

ios_base::fmtflags baseflags = ios_base::flags() & ios_base::basefield;
bool failed = use_facet<
  num_put<charT, ostreambuf_iterator<charT, traits>>
    >(getloc()).put(*this, *this, fill(),
    baseflags == ios_base::oct || baseflags == ios_base::hex
      ? static_cast<long>(static_cast<unsigned short>(val))
      : static_cast<long>(val)).failed();

Когда val is of type, int преобразование форматирования происходит так, как если бы оно выполняло следующий фрагмент кода:

ios_base::fmtflags baseflags = ios_base::flags() & ios_base::basefield;
bool failed = use_facet<
  num_put<charT, ostreambuf_iterator<charT, traits>>
    >(getloc()).put(*this, *this, fill(),
    baseflags == ios_base::oct || baseflags == ios_base::hex
      ? static_cast<long>(static_cast<unsigned int>(val))
      : static_cast<long>(val)).failed();

When val is of type unsigned short или unsigned int преобразование форматирования происходит так, как если бы оно выполняло следующий фрагмент кода:

bool failed = use_facet<
  num_put<charT, ostreambuf_iterator<charT, traits>>
    >(getloc()).put(*this, *this, fill(),
      static_cast<unsigned long>(val)).failed();

Когда val is of type, float преобразование форматирования происходит так, как если бы оно выполняло следующий фрагмент кода:

bool failed = use_facet<
  num_put<charT, ostreambuf_iterator<charT, traits>>
    >(getloc()).put(*this, *this, fill(),
      static_cast<double>(val)).failed();

Первый аргумент предоставляет объект ostreambuf_­iterator<> класса, который является итератором для класса basic_­ostream<>. Он обходит ostreams и использует streambufs напрямую. Класс locale полагается на эти типы как на свой интерфейс к iostreams, поскольку для гибкости он абстрагирован от прямой зависимости от ostream. Второй параметр - это ссылка на подобъект базового класса типа ios_­base. Он предоставляет спецификации форматирования, такие как ширина поля и языковой стандарт, из которого можно получить другие фасеты. Если failed есть, true то это setstate(badbit)может вызвать исключение и вернуться.

Returns: *this.

30.7.5.2.3 basic_­ostream​::​operator<< [ostream.inserters]

basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>&));

Effects: Никто. Не работает как функция форматированного вывода (как описано в [ostream.formatted.reqmts]).

Returns: pf(*this).321

basic_ostream<charT, traits>& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));

Effects: Звонки pf(*this). Этот модуль вставки не работает как функция форматированного вывода (как описано в разделе [ostream.formatted.reqmts]).

Returns: *this.322

basic_ostream<charT, traits>& operator<<(ios_base& (*pf)(ios_base&));

Effects: Звонки pf(*this). Этот модуль вставки не работает как функция форматированного вывода (как описано в разделе [ostream.formatted.reqmts]).

Returns: *this.

basic_ostream<charT, traits>& operator<<(basic_streambuf<charT, traits>* sb);

Effects: Ведет себя как unformatted output function. После того, как объект-часовой создан, if sb является нулевым вызовом setstate(badbit) (который может вызывать ios_­base​::​failure).

Получает символы из sb и вставляет их в *this. Символы считываются sb и вставляются до тех пор, пока не произойдет одно из следующих событий:

  • конец файла встречается во входной последовательности;

  • вставка в выходную последовательность не выполняется (в этом случае вставляемый символ не извлекается);

  • исключение возникает при получении символа из sb.

Если функция не вставляет символы, она вызывает setstate(failbit) (что может вызвать throw ios_­base​::​​failure ([iostate.flags])). Если было брошено исключение при извлечении персонажа, функция устанавливает failbit в состоянии ошибки, и если failbit на в exceptions() пойманном исключении является вызвано повторно.

Returns: *this.

basic_ostream<charT, traits>& operator<<(nullptr_t);

Effects: Эквивалентен:

return *this << s;

где s определяется реализацией NTCTS.

См., Например, сигнатуру функции endl(basic_­ostream&).

См., Например, сигнатуру функции dec(ios_­base&).

30.7.5.2.4 Character inserter function templates [ostream.inserters.character]

template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& out, charT c); template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& out, char c); // specialization template<class traits> basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, char c); // signed and unsigned template<class traits> basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, signed char c); template<class traits> basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, unsigned char c);

Effects: Ведет себя как formatted output function оф out. Создает последовательность символов seq. Если c имеет тип, char а символьный тип потока - нет char, то seq состоит из out.widen(c); в противном случае seq состоит из c. Определяет заполнение, seq как описано в [ostream.formatted.reqmts]. Вставляет seq в out. Звонки os.width(0).

Returns: out.

template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& out, const charT* s); template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& out, const char* s); template<class traits> basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, const char* s); template<class traits> basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, const signed char* s); template<class traits> basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, const unsigned char* s);

Requires: s не должен быть нулевым указателем.

Effects: Работает как форматированный модуль вставки (как описано в разделе [ostream.formatted.reqmts]) из out. Создает последовательность символов seq из n символов , начиная с s, каждый расширена с помощью out.widen() ([basic.ios.members]), где n это число , которое будет вычислено как бы:

  • traits​::​length(s) для перегрузки, где первый аргумент имеет тип, basic_­ostream<charT, traits>& а второй - типа const charT*, а также для перегрузки, где первый аргумент имеет тип, basic_­ostream<char, traits>& а второй - тип const char*,

  • char_­traits<char>​::​length(s) для перегрузки, где первый аргумент имеет тип, basic_­ostream<charT, traits>& а второй - тип const char*,

  • traits​::​length(reinterpret_­cast<const char*>(s)) для двух других перегрузок.

Определяет заполнение, seq как описано в [ostream.formatted.reqmts]. Вставляет seq в out. Звонки width(0).

Returns: out.

30.7.5.3 Unformatted output functions [ostream.unformatted]

Каждая функция неформатированного вывода начинает выполнение с создания объекта класса sentry. Если этот объект возвращается trueпри преобразовании в значение типа bool, функция пытается сгенерировать запрошенный вывод. Если во время вывода возникает исключение, то ios​::​badbit включается323 в *thisсостоянии ошибки. Если (exceptions() & badbit) != 0 тогда исключение генерируется повторно. В любом случае функция неформатированного вывода завершается уничтожением охранного объекта, а затем, если не было сгенерировано исключение, возвращает значение, указанное для функции неформатированного вывода.

basic_ostream<charT, traits>& put(char_type c);

Effects: Ведет себя как неформатированная функция вывода (как описано выше). После создания сторожевого объекта c, если возможно , вставляет символ .324

В противном случае вызовы setstate(badbit) (которые могут бросить ios_­base​::​failure ([iostate.flags])).

Returns: *this.

basic_ostream& write(const char_type* s, streamsize n);

Effects: Ведет себя как неформатированная функция вывода (как описано выше). После создания сторожевого объекта получает символы для вставки из последовательных мест массива, первый элемент которого обозначен s.325 Символы вставляются до тех пор, пока не произойдет одно из следующих событий:

  • n вставляются символы;

  • вставка в выходную последовательность не выполняется (в этом случае вызывается функция setstate(badbit), которая может throw ios_­base​::​failure ([iostate.flags])).

Returns: *this.

basic_ostream& flush();

Effects: Ведет себя как неформатированная функция вывода (как описано выше). Если rdbuf() не является нулевым указателем, создает объект-часовой. Если этот объект возвращается true при преобразовании в значение типа, bool функция вызывает rdbuf()->pubsync(). Если эта функция возвращает -1 вызов setstate(badbit) (который может throw ios_­base​::​failure ([iostate.flags])). В противном случае, если объект-часовой возвращается false, ничего не делает.

Returns: *this.

не вызывая ios​::​failure броска.

Обратите внимание, что эта функция не перегружена для типов signed char и unsigned char.

Обратите внимание, что эта функция не перегружена для типов signed char и unsigned char.

30.7.5.4 Standard basic_­ostream manipulators [ostream.manip]

template <class charT, class traits> basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);

Effects: os.put(os.widen('\n'))Тогда звонит os.flush().

Returns: os.

template <class charT, class traits> basic_ostream<charT, traits>& ends(basic_ostream<charT, traits>& os);

Effects: Вставляет нулевой символ в выходную последовательность: calls os.put(charT()).

Returns: os.

template <class charT, class traits> basic_ostream<charT, traits>& flush(basic_ostream<charT, traits>& os);

Effects: Звонки os.flush().

Returns: os.

30.7.5.5 Rvalue stream insertion [ostream.rvalue]

template <class charT, class traits, class T> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&& os, const T& x);

Effects: Как будто по: os << x;

Returns: os.

Remarks: Эта функция не должна участвовать в разрешении перегрузки, если выражение os << x не сформировано правильно.

30.7.6 Standard manipulators [std.manip]

Заголовок <iomanip> определяет несколько функций, которые поддерживают экстракторы и средства вставки, которые изменяют информацию, поддерживаемую классом ios_­base и его производными классами.

unspecified resetiosflags(ios_base::fmtflags mask);

Returns: Объект неопределенного типа, такой, что если out это объект типа, basic_­ostream<charT, traits> тогда выражение out << resetiosflags(mask) ведет себя так, как если бы оно было вызвано f(out, mask), или если in это объект типа, basic_­istream<charT, traits> тогда выражение in >> resetiosflags(​mask) ведет себя так, как если бы оно было вызвано f(in, mask), где функция f определяется как:326

void f(ios_base& str, ios_base::fmtflags mask) {
  // reset specified flags
  str.setf(ios_base::fmtflags(0), mask);
}

Выражение out << resetiosflags(mask) должно иметь тип basic_­ostream<charT, traits>& и значение out. Выражение in >> resetiosflags(mask) должно иметь тип basic_­istream<charT, traits>& и значение in.

unspecified setiosflags(ios_base::fmtflags mask);

Returns: Объект неопределенного типа, такой, что если out это объект типа, basic_­ostream<charT, traits> тогда выражение out << setiosflags(mask) ведет себя так, как если бы оно было вызвано f(out, mask), или если in это объект типа, basic_­istream<charT, traits> тогда выражение in >> setiosflags(mask) ведет себя так, как если бы оно было вызвано f(in, mask), где функция f определяется как:

void f(ios_base& str, ios_base::fmtflags mask) {
  // set specified flags
  str.setf(mask);
}

Выражение out << setiosflags(mask) должно иметь тип basic_­ostream<charT, traits>& и значение out. Выражение in >> setiosflags(mask) должно иметь тип basic_­istream<charT,
traits>&
и значение in.

unspecified setbase(int base);

Returns: Объект неопределенного типа, такой, что если out это объект типа, basic_­ostream<charT, traits> тогда выражение out << setbase(base) ведет себя так, как если бы оно было вызвано f(out, base), или если in это объект типа, basic_­istream<charT, traits> тогда выражение in >> setbase(base) ведет себя так, как если бы оно было вызвано f(in, base), где функция f определяется как:

void f(ios_base& str, int base) {
  // set basefield
  str.setf(base ==  8 ? ios_base::oct :
      base == 10 ? ios_base::dec :
      base == 16 ? ios_base::hex :
      ios_base::fmtflags(0), ios_base::basefield);
}

Выражение out << setbase(base) должно иметь тип basic_­ostream<charT, traits>& и значение out. Выражение in >> setbase(base) должно иметь тип basic_­istream<charT, traits>& и значение in.

unspecified setfill(char_type c);

Returns: Объект неопределенного типа, такой, что if out является объектом типа basic_­ostream<charT, traits> и c имеет тип, charT тогда выражение out << setfill(c) ведет себя так, как если бы оно было вызвано f(out, c), где функция f определяется как:

template<class charT, class traits>
void f(basic_ios<charT, traits>& str, charT c) {
  // set fill character
  str.fill(c);
}

Выражение out << setfill(c) должно иметь тип basic_­ostream<charT, traits>& и значение out.

unspecified setprecision(int n);

Returns: Объект неопределенного типа, такой, что если out это объект типа, basic_­ostream<charT, traits> тогда выражение out << setprecision(n) ведет себя так, как если бы оно было вызвано f(out, n), или если in это объект типа, basic_­istream<charT, traits> тогда выражение in >> setprecision(n) ведет себя так, как если бы оно было вызвано f(in, n), где функция f определяется как:

void f(ios_base& str, int n) {
  // set precision
  str.precision(n);
}

Выражение out << setprecision(n) должно иметь тип basic_­ostream<charT, traits>& и значение out. Выражение in >> setprecision(n) должно иметь тип basic_­istream<charT, traits>& и значение in.

unspecified setw(int n);

Returns: Объект неопределенного типа, такой, что если out является экземпляром, basic_­ostream<charT, traits> тогда выражение out << setw(n) ведет себя так, как если бы оно было вызвано f(out, n), или если in это объект типа, basic_­istream<charT, traits> то выражение in >> setw(n) ведет себя так, как если бы оно было вызвано f(in, n), где функция f определяется как:

void f(ios_base& str, int n) {
  // set width
  str.width(n);
}

Выражение out << setw(n) должно иметь тип basic_­ostream<charT, traits>& и значение out. Выражение in >> setw(n) должно иметь тип basic_­istream<charT, traits>& и значение in.

Выражение cin >> resetiosflags(ios_­base​::​skipws) очищается ios_­base​::​skipws во флагах формата, хранящихся в basic_­istream<charT, traits> объекте cin (так же, как cin >> noskipws), а выражение cout << resetiosflags(ios_­base​::​showbase) очищается ios_­base​::​showbase во флагах формата, хранящихся в basic_­ostream<charT, traits> объекте cout (как cout << noshowbase).

30.7.7 Extended manipulators [ext.manip]

Заголовок <iomanip> определяет несколько функций, которые поддерживают экстракторы и вставщики, которые позволяют анализировать и форматировать последовательности и значения за деньги и время.

template <class moneyT> unspecified get_money(moneyT& mon, bool intl = false);

Requires: Тип moneyT должен быть либо long double специализацией basic_­string шаблона (пункт [strings]), либо его специализацией .

Effects: Выражение, in >> get_­money(mon, intl) описанное ниже, ведет себя как formatted input function.

Returns: Объект неопределенного типа, такой что if in является объектом типа, basic_­istream<charT, traits> тогда выражение in >> get_­money(mon, intl) ведет себя так, как если бы оно было вызвано f(in, mon, intl), где функция f определяется как:

template <class charT, class traits, class moneyT>
void f(basic_ios<charT, traits>& str, moneyT& mon, bool intl) {
  using Iter     = istreambuf_iterator<charT, traits>;
  using MoneyGet = money_get<charT, Iter>;

  ios_base::iostate err = ios_base::goodbit;
  const MoneyGet& mg = use_facet<MoneyGet>(str.getloc());

  mg.get(Iter(str.rdbuf()), Iter(), intl, str, err, mon);

  if (ios_base::goodbit != err)
    str.setstate(err);
}

Выражение in >> get_­money(mon, intl) должно иметь тип basic_­istream<charT, traits>& и значение in.

template <class moneyT> unspecified put_money(const moneyT& mon, bool intl = false);

Requires: Тип moneyT должен быть либо long double специализацией basic_­string шаблона (пункт [strings]), либо его специализацией .

Returns: Объект неопределенного типа, такой что if out является объектом типа, basic_­ostream<charT, traits> тогда выражение out << put_­money(mon, intl) ведет себя как formatted output function вызывающий объектf(out, mon, intl), где функция f определяется как:

template <class charT, class traits, class moneyT>
void f(basic_ios<charT, traits>& str, const moneyT& mon, bool intl) {
  using Iter     = ostreambuf_iterator<charT, traits>;
  using MoneyPut = money_put<charT, Iter>;

  const MoneyPut& mp = use_facet<MoneyPut>(str.getloc());
  const Iter end = mp.put(Iter(str.rdbuf()), intl, str, str.fill(), mon);

  if (end.failed())
    str.setstate(ios::badbit);
}

Выражение out << put_­money(mon, intl) должно иметь тип basic_­ostream<charT, traits>& и значение out.

template <class charT> unspecified get_time(struct tm* tmb, const charT* fmt);

Requires: Аргумент tmb должен быть действительным указателем на объект типа struct tm. Аргумент fmt должен быть действительным указателем на массив объектов типа charT с char_­traits<charT>​::​length(fmt) элементами.

Returns: Объект неопределенного типа, такой что if in является объектом типа, basic_­istream<charT, traits> тогда выражение in >> get_­time(tmb, fmt) ведет себя так, как если бы оно было вызвано f(in, tmb, fmt), где функция f определяется как:

template <class charT, class traits>
void f(basic_ios<charT, traits>& str, struct tm* tmb, const charT* fmt) {
  using Iter    = istreambuf_iterator<charT, traits>;
  using TimeGet = time_get<charT, Iter>;

  ios_base::iostate err = ios_base::goodbit;
  const TimeGet& tg = use_facet<TimeGet>(str.getloc());

  tg.get(Iter(str.rdbuf()), Iter(), str, err, tmb,
    fmt, fmt + traits::length(fmt));

  if (err != ios_base::goodbit)
    str.setstate(err);
}

Выражение in >> get_­time(tmb, fmt) должно иметь тип basic_­istream<charT, traits>& и значение in.

template <class charT> unspecified put_time(const struct tm* tmb, const charT* fmt);

Requires: Аргумент tmb должен быть действительным указателем на объект типа struct tm, а аргумент fmt должен быть действительным указателем на массив объектов типа charT с char_­traits<charT>​::​length(​fmt) элементами.

Returns: Объект неопределенного типа, такой что if out является объектом типа, basic_­ostream<charT, traits> тогда выражение out << put_­time(tmb, fmt) ведет себя так, как если бы оно было вызвано f(out, tmb, fmt), где функция f определяется как:

template <class charT, class traits>
void f(basic_ios<charT, traits>& str, const struct tm* tmb, const charT* fmt) {
  using Iter    = ostreambuf_iterator<charT, traits>;
  using TimePut = time_put<charT, Iter>;

  const TimePut& tp = use_facet<TimePut>(str.getloc());
  const Iter end = tp.put(Iter(str.rdbuf()), str, str.fill(), tmb,
    fmt, fmt + traits::length(fmt));

  if (end.failed())
    str.setstate(ios_base::badbit);
}

Выражение out << put_­time(tmb, fmt) должно иметь тип basic_­ostream<charT, traits>& и значение out.

30.7.8 Quoted manipulators [quoted.manip]

[ Note: Манипуляторы с кавычками обеспечивают вставку и извлечение строк в кавычках (например, в форматах XML и CSV). Цитированные манипуляторы полезны для обеспечения того, чтобы содержимое строки со встроенными пробелами оставалось неизменным, если оно вставлено и затем извлечено с помощью потокового ввода-вывода. ] end note

template <class charT> unspecified quoted(const charT* s, charT delim = charT('"'), charT escape = charT('\\')); template <class charT, class traits, class Allocator> unspecified quoted(const basic_string<charT, traits, Allocator>& s, charT delim = charT('"'), charT escape = charT('\\')); template <class charT, class traits> unspecified quoted(basic_string_view<charT, traits> s, charT delim = charT('"'), charT escape = charT('\\'));

Returns: Объект неопределенного типа, такой что if out является экземпляром basic_­ostream с типом члена, char_­type таким же, как charT и с типом члена traits_­type, который во второй и третьей формах совпадает с traits, тогда выражение out << quoted(s, delim, escape) ведет себя как a formatted output function of out. Это формирует последовательность символов seq, изначально состоящую из следующих элементов:

  • delim.

  • Каждый персонаж в s. Если выводимый символ равен escape или delim, как определено traits_­type​::​eq, первый вывод escape.

  • delim.

Позвольте x быть количество элементов первоначально в seq. Затем определяется заполнение, seq как описано в [ostream.formatted.reqmts], seq вставляется, как если бы при вызове out.rdbuf()->sputn(seq, n), где n больше из out.width() и x, и out.width(0) вызывается. Выражение out << quoted(s, delim, escape) должно иметь тип basic_­ostream<charT, traits>& и значение out.

template <class charT, class traits, class Allocator> unspecified quoted(basic_string<charT, traits, Allocator>& s, charT delim = charT('"'), charT escape = charT('\\'));

Returns: Объект неопределенного типа, такой что:

  • Если in это экземпляр basic_­istream с типами членов char_­type и traits_­type то же самое, что charT и traits, соответственно, тогда выражение in >> quoted(s, delim, escape) ведет себя так, как если бы оно извлекало следующие символы из in using operator>>(basic_­istream<charT, traits>&, charT&) ([istream.extractors]), которое может throw ios_­base​::​failure ([ios::failure]):

    • Если первый извлеченный символ равен delim, как определено traits_­type​::​eq, то:

      • Снимите skipws флаг.

      • s.clear()

      • Пока не будет delim достигнут неэкранированный символ или !in, извлеките символы из in и добавьте их s, за исключением того, что если escape достигнут, игнорируйте его и добавляйте следующий символ к s.

      • Отбросьте последний delim символ.

      • Восстановите skipws исходное значение флага.

    • В противном случае in >> s.

  • Если out - это экземпляр basic_­ostream с типами членов char_­type и traits_­type то же самое, что charT и и traits, соответственно, тогда выражение out << quoted(s, delim, escape) ведет себя так, как указано для const basic_­string<charT, traits, Allocator>& перегрузки quoted функции.

Выражение in >> quoted(s, delim, escape) должно иметь тип basic_­istream<charT, traits>& и значение in. Выражение out << quoted(s, delim, escape) должно иметь тип basic_­ostream​<charT, traits>& и значение out.