Annex D (normative) Compatibility features [depr]

Заголовок <ccomplex> ведет себя так, как будто он просто включает заголовок <complex> ([complex.syn]).

Содержимое заголовка <cstdalign> такое же, как заголовок стандартной библиотеки C <stdalign.h>, со следующими изменениями: Заголовок <cstdalign> и заголовок <stdalign.h> не должны определять названный макрос alignas.

См. Также: ISO C 7.15.

Содержимое заголовка <cstdbool> такие же , как заголовок стандартной библиотеки C <stdbool.h>, со следующими изменениями: заголовок <cstdbool> и заголовок <stdbool.h> не должен определять макросы с именем bool, trueили false.

См. Также: ISO C 7.18.

Заголовок <ctgmath> просто включает заголовки <complex> ([complex.syn]) и <cmath> ([cmath.syn]).

[  Note: Перегрузка , предусмотренная в С помощью макросов типа унифицированного уже предусмотрены в <complex> и с <cmath> помощью «достаточных» дополнительных перегрузок. ] — end note 

Класс strstreambuf связывает входную последовательность и, возможно, выходную последовательность с объектом некоторого character типа массива, элементы которого хранят произвольные значения. У объекта массива есть несколько атрибутов.

[  Note: Для наглядности они представлены как элементы типа битовой маски (обозначены здесь как T1) с именем strstate. Элементами являются:

• (2.1)

  allocated, устанавливается, когда объект динамического массива был выделен и, следовательно, должен быть освобожден деструктором этого strstreambuf объекта;

• (2.2)

  constant, устанавливается, когда объект массива имеет const элементы, поэтому выходная последовательность не может быть записана;

• (2.3)

  dynamic, устанавливается, когда объект массива выделяется (или перераспределяется) по мере необходимости для хранения последовательности символов, длина которой может изменяться;

• (2.4)

  frozen, устанавливается, когда программа запросила, чтобы объект массива не был изменен, перераспределен или освобожден.

 — end note ]

[  Note: Для демонстрации поддерживаемые данные представлены здесь как:

• (3.1)

  strstate strmode, атрибуты объекта массива, связанные с strstreambuf объектом;

• (3.2)

  int alsize, рекомендуемый минимальный размер объекта динамического массива;

• (3.3)

  void* (*palloc)(size_­t), указывает на функцию, которую нужно вызвать для выделения объекта динамического массива;

• (3.4)

  void (*pfree)(void*), указывает на функцию, вызываемую для освобождения объекта динамического массива.

 — end note ]

Каждый объект класса strstreambuf имеет seekable area, разделенный указателями seeklow и seekhigh. Если gnext это нулевой указатель, область поиска не определена. В противном случае seeklow равно gbeg и seekhigh равно либо pend, если pend не является нулевым указателем, либо gend.

Класс istrstream поддерживает чтение объектов класса strstreambuf. Он предоставляет strstreambuf объект для управления связанным объектом массива. Для демонстрации поддерживаемые данные представлены здесь как:

• (1.1)

  sb, strstreambuf объект.

Класс ostrstream поддерживает запись объектов класса strstreambuf. Он предоставляет strstreambuf объект для управления связанным объектом массива. Для демонстрации поддерживаемые данные представлены здесь как:

• (1.1)

  sb, strstreambuf объект.

Класс strstream поддерживает чтение и запись из объектов класса strstreambuf. Он предоставляет strstreambuf объект для управления связанным объектом массива. Для демонстрации поддерживаемые данные представлены здесь как:

• (1.1)

  sb, strstreambuf объект.

А call wrapper может иметь weak result type. Если это так, тип его типа члена result_­type основан на типе T целевого объекта оболочки:

• (1.1)

  если T - указатель на тип функции, result_­type должен быть синонимом возвращаемого типа T;

• (1.2)

  если T - указатель на функцию-член, result_­type должен быть синонимом возвращаемого типа T;

• (1.3)

  если T это тип класса, а qualified-id T​::​result_­type действительный и обозначает тип ([temp.deduct]), то result_­type должен быть синонимом для T​::​result_­type;

• (1.4)

  иначе result_­type не определяется.

Чтобы включить старые функции адаптеров для управления объектами функции , которые принимают один или два аргумент, многие из функциональных объектов в настоящем стандарте , соответственно , обеспечивают typedef-names argument_­type и result_­type для функциональных объектов , которые принимают один аргумент и first_­argument_­type, second_­argument_­typeи result_­type для функциональных объектов , которые принимают два аргумента.

Следующие имена членов определены в дополнение к именам, указанным в Пункте [function.objects]:

namespace std {
  template<class T> struct owner_less<shared_ptr<T>> {
    using result_type          = bool;
    using first_argument_type  = shared_ptr<T>;
    using second_argument_type = shared_ptr<T>;
  };

  template<class T> struct owner_less<weak_ptr<T>> {
    using result_type          = bool;
    using first_argument_type  = weak_ptr<T>;
    using second_argument_type = weak_ptr<T>;
  };

  template <class T> class reference_wrapper {
  public :
    using result_type          = see below; // not always defined
    using argument_type        = see below; // not always defined
    using first_argument_type  = see below; // not always defined
    using second_argument_type = see below; // not always defined
  };

  template <class T> struct plus {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = T;
  };

  template <class T> struct minus {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = T;
  };

  template <class T> struct multiplies {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = T;
  };

  template <class T> struct divides {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = T;
  };

  template <class T> struct modulus {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = T;
  };

  template <class T> struct negate {
    using argument_type = T;
    using result_type   = T;
  };

  template <class T> struct equal_to {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = bool;
  };

  template <class T> struct not_equal_to {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = bool;
  };

  template <class T> struct greater {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = bool;
  };

  template <class T> struct less {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = bool;
  };

  template <class T> struct greater_equal {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = bool;
  };

  template <class T> struct less_equal {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = bool;
  };

  template <class T> struct logical_and {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = bool;
  };

  template <class T> struct logical_or {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = bool;
  };

  template <class T> struct logical_not {
    using argument_type = T;
    using result_type   = bool;
  };

  template <class T> struct bit_and {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = T;
  };

  template <class T> struct bit_or {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = T;
  };

  template <class T> struct bit_xor {
    using first_argument_type  = T;
    using second_argument_type = T;
    using result_type          = T;
  };

  template <class T> struct bit_not {
    using argument_type = T;
    using result_type   = T;
  };

  template<class R, class T1>
  class function<R(T1)> {
  public:
    using argument_type = T1;
  };

  template<class R, class T1, class T2>
  class function<R(T1, T2)> {
  public:
    using first_argument_type  = T1;
    using second_argument_type = T2;
  };
}

reference_­wrapper<T> имеет weak result type. Если T - это тип функции, result_­type должен быть синонимом возвращаемого типа T.

Специализация шаблона reference_­wrapper<T> должна определять вложенный тип, названный argument_­type как синоним, T1 только если тип T является одним из следующих:

• (4.1)

  тип функции или указатель на тип функции, принимающий один аргумент типа T1

• (4.2)

  указатель на функцию-член R T0​::​f() cv (где cv представляет cv-квалификаторы функции-члена); тип T1 это cv T0*

• (4.3)

  тип класса, где qualified-id T​::​argument_­type допустим и обозначает тип ([temp.deduct]); тип T1 есть T​::​argument_­type.

Создание экземпляра шаблона reference_­wrapper<T> должно определять два вложенных типа с именами first_­argument_­type и second_­argument_­type как синонимы для T1 и T2, соответственно, только если тип T является одним из следующих:

• (5.1)

  тип функции или указатель на тип функции, принимающий два аргумента типа T1 и T2

• (5.2)

  указатель на функцию-член R T0​::​f(T2) cv (где cv представляет cv-квалификаторы функции-члена); тип T1 это cv T0*

• (5.3)

  тип класса , где qualified-ids T​::​first_­argument_­type и T​::​second_­argument_­type являются действительными и оба типа обозначают ([temp.deduct]); тип T1 есть T​::​first_­argument_­type и тип T2 есть T​::​second_­argument_­type.

Все включенные специализации hash<Key> из hash ([unord.hash]) обеспечивают два вложенных типов, result_­type и argument_­type, которые должны быть синонимы size_­t и Key, соответственно.

Обертка переадресации вызовов, g возвращаемая вызовом bind(f, bound_­args...) ([func.bind.bind]), должна иметь weak result type.

Обертка переадресации вызова, g возвращаемая вызовом bind<R>(f, bound_­args...) ([func.bind.bind]), должна иметь вложенный тип, result_­type определенный как синоним для R.

Простая оболочка вызова, возвращаемая из вызова, mem_­fn(pm) должна иметь вложенный тип, result_­type который является синонимом возвращаемого типа, pm когда pm является указателем на функцию-член.

Простая оболочка вызова, возвращаемая при вызове, mem_­fn(pm) должна определять два вложенных типа с именами argument_­type и result_­type как синонимы для cv T* и Ret, соответственно, когда pm является указателем на функцию-член с квалификатором cv cv и не принимает аргументов, где Ret - pmтип возвращаемого значения.

Простая оболочка вызова, возвращаемая из вызова, mem_­fn(pm) должна определять три вложенных типа с именами first_­argument_­type, second_­argument_­typeи result_­type как синонимы для cv T*, T1и Ret, соответственно, когда pm является указателем на функцию-член с квалификатором cv cv и принимает один аргумент типа T1, где Ret - pmэто return тип.

Следующие имена членов определены в дополнение к именам, указанным в Пункте [containers]:

namespace std {
  template <class Key, class T, class Compare, class Allocator>
  class map<Key, T, Compare, Allocator>::value_compare {
  public:
    using result_type          = bool;
    using first_argument_type  = value_type;
    using second_argument_type = value_type;
  };

  template <class Key, class T, class Compare, class Allocator>
  class multimap<Key, T, Compare, Allocator>::value_compare {
  public:
    using result_type          = bool;
    using first_argument_type  = value_type;
    using second_argument_type = value_type;
  };
}

В шапку внесены следующие дополнения:<functional>

namespace std {
  template <class Predicate> class unary_negate;
  template <class Predicate>
    constexpr unary_negate<Predicate> not1(const Predicate&);
  template <class Predicate> class binary_negate;
  template <class Predicate>
    constexpr binary_negate<Predicate> not2(const Predicate&);
}

Отрицатели not1 и not2 принимают унарный и бинарный предикаты соответственно и возвращают их логические отрицания ([expr.unary.op]).

template <class Predicate>
class unary_negate {
public:
  constexpr explicit unary_negate(const Predicate& pred);
  constexpr bool operator()(const typename Predicate::argument_type& x) const;
  using argument_type = typename Predicate::argument_type;
  using result_type   = bool;
};

В шапке есть следующее дополнение:<iterator>

namespace std {
  template<class Category, class T, class Distance = ptrdiff_t,
    class Pointer = T*, class Reference = T&>
  struct iterator {
    using iterator_category = Category;
    using value_type        = T;
    using difference_type   = Distance;
    using pointer           = Pointer;
    using reference         = Reference;
  };
}

iterator Шаблон может быть использован в качестве базового класса , чтобы облегчить определение необходимых типов для новых итераторов.

[  Note: Если новый тип итератора является шаблоном класса, то эти псевдонимы не будут видны из определения шаблона класса итератора, а будут видны только вызывающим объектам этого класса. ] — end note 

[  Example: Если программа на C ++ хочет определить двунаправленный итератор для некоторой структуры данных, содержащей double и такой, чтобы она работала на большой модели памяти реализации, она может сделать это с помощью:

class MyIterator :
  public iterator<bidirectional_iterator_tag, double, long, T*, T&> {
  // code implementing ++, etc.
};

 — end example ]

Для каждого из трех аспектов преобразования кода codecvt_­utf8, codecvt_­utf16и codecvt_­utf8_­utf16:

• (1.1)

  Elem тип широких символов, например wchar_­t, char16_­tили char32_­t.

• (1.2)

  Maxcode - это самый большой код с широкими символами, который фасет будет читать или писать без сообщения об ошибке преобразования.

• (1.3)

  Если (Mode & consume_­header), то при чтении многобайтовой последовательности фасет должен использовать начальную последовательность заголовка, если она присутствует, для определения порядка следования байтов последующей многобайтовой последовательности, которая должна быть прочитана.

• (1.4)

  Если (Mode & generate_­header), фасет должен генерировать начальную последовательность заголовка при записи многобайтовой последовательности, чтобы объявить о порядке следования записываемой последующей многобайтовой последовательности.

• (1.5)

  Если (Mode & little_­endian), фасет должен генерировать многобайтовую последовательность в обратном порядке, в отличие от стандартного обратного порядка байтов.

Для грани : codecvt_­utf8

• (2.1)

  Фасет должен преобразовывать многобайтовые последовательности UTF-8 в UCS2 или UCS4 (в зависимости от размера Elem) в программе.

• (2.2)

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

• (2.3)

  Многобайтовые последовательности могут быть записаны в виде текстового или двоичного файла.

Для грани : codecvt_­utf16

• (3.1)

  Фасет должен преобразовывать многобайтовые последовательности UTF-16 в UCS2 или UCS4 (в зависимости от размера Elem) в программе.

• (3.2)

  Многобайтовые последовательности должны читаться или записываться в соответствии с указанным выше Mode флагом.

• (3.3)

  Многобайтовые последовательности могут быть записаны только как двоичный файл. Попытка записи в текстовый файл приводит к неопределенному поведению.

Для грани : codecvt_­utf8_­utf16

• (4.1)

  Фасет должен преобразовывать многобайтовые последовательности UTF-8 в UTF-16 (один или два 16-битных кода) в программе.

• (4.2)

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

• (4.3)

  Многобайтовые последовательности могут быть записаны в виде текстового или двоичного файла.

См. Также: ISO / IEC 10646-1: 1993.

Шаблон класса wstring_­convert выполняет преобразования между широкой строкой и байтовой строкой. Он позволяет указать фасет преобразования кода (например, шаблон класса codecvt) для выполнения преобразований, не затрагивая какие-либо потоки или языковые стандарты. [  Example: Если вы хотите использовать фасет преобразования кода codecvt_­utf8 для вывода в cout многобайтовую последовательность UTF-8, соответствующую широкой строке, но вы не хотите изменять языковой стандарт cout, вы можете написать что-то вроде:

wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
std::string mbstring = myconv.to_bytes(L"Hello\n");
std::cout << mbstring;

 — end example ]

namespace std {
  template <class Codecvt, class Elem = wchar_t,
            class Wide_alloc = allocator<Elem>,
            class Byte_alloc = allocator<char>>
    class wstring_convert {
    public:
      using byte_string = basic_string<char, char_traits<char>, Byte_alloc>;
      using wide_string = basic_string<Elem, char_traits<Elem>, Wide_alloc>;
      using state_type  = typename Codecvt::state_type;
      using int_type    = typename wide_string::traits_type::int_type;

      explicit wstring_convert(Codecvt* pcvt = new Codecvt);
      wstring_convert(Codecvt* pcvt, state_type state);
      explicit wstring_convert(const byte_string& byte_err,
                               const wide_string& wide_err = wide_string());
      ~wstring_convert();

      wstring_convert(const wstring_convert&) = delete;
      wstring_convert& operator=(const wstring_convert&) = delete;

      wide_string from_bytes(char byte);
      wide_string from_bytes(const char* ptr);
      wide_string from_bytes(const byte_string& str);
      wide_string from_bytes(const char* first, const char* last);

      byte_string to_bytes(Elem wchar);
      byte_string to_bytes(const Elem* wptr);
      byte_string to_bytes(const wide_string& wstr);
      byte_string to_bytes(const Elem* first, const Elem* last);

      size_t converted() const noexcept;
      state_type state() const;

    private:
      byte_string byte_err_string;  // exposition only
      wide_string wide_err_string;  // exposition only
      Codecvt* cvtptr;              // exposition only
      state_type cvtstate;          // exposition only
      size_t cvtcount;              // exposition only
    };
}

Шаблон класса описывает объект, который управляет преобразованиями между объектами широких строк класса basic_­string<Elem, char_­traits<Elem>, Wide_­alloc> и объектами байтовых строк класса basic_­string<char, char_­traits<char>, Byte_­alloc>. Шаблон класса определяет типы wide_­string и byte_­string как синонимы для этих двух типов. Преобразование между последовательностью Elem значений (хранящейся в wide_­string объекте) и многобайтовыми последовательностями (хранящейся в byte_­string объекте) выполняется объектом класса Codecvt, который соответствует требованиям стандартного аспекта преобразования кода codecvt<Elem, char, mbstate_­t>.

В объекте этого шаблона класса хранятся:

• (3.1)

  byte_­err_­string - строка байтов для отображения при ошибках

• (3.2)

  wide_­err_­string - широкая строка для отображения при ошибках

• (3.3)

  cvtptr - указатель на выделенный объект преобразования (который освобождается при wstring_­convert уничтожении объекта)

• (3.4)

  cvtstate - объект состояния преобразования

• (3.5)

  cvtcount - счетчик конверсий

Шаблон класса wbuffer_­convert выглядит как широкий буфер потока, но все операции ввода-вывода выполняются через нижележащий буфер потока байтов, который вы указываете при его создании. Как и шаблон класса wstring_­convert, он позволяет указать фасет преобразования кода для выполнения преобразований, не затрагивая никакие потоки или языковые стандарты.

namespace std {
  template <class Codecvt, class Elem = wchar_t, class Tr = char_traits<Elem>>
    class wbuffer_convert : public basic_streambuf<Elem, Tr> {
    public:
      using state_type = typename Codecvt::state_type;

      explicit wbuffer_convert(streambuf* bytebuf = 0,
                               Codecvt* pcvt = new Codecvt,
                               state_type state = state_type());

      ~wbuffer_convert();

      wbuffer_convert(const wbuffer_convert&) = delete;
      wbuffer_convert& operator=(const wbuffer_convert&) = delete;

      streambuf* rdbuf() const;
      streambuf* rdbuf(streambuf* bytebuf);

      state_type state() const;

    private:
      streambuf* bufptr;            // exposition only
      Codecvt* cvtptr;              // exposition only
      state_type cvtstate;          // exposition only
  };
}

Шаблон класса описывает буфер потока, который управляет передачей элементов типа Elem, характеристики символов которых описываются классом Tr, в буфер потока байтов типа и из него streambuf. Преобразование между последовательностью Elem значений и многобайтовыми последовательностями выполняется объектом класса Codecvt, который должен удовлетворять требованиям стандартного аспекта преобразования кода codecvt<Elem, char, mbstate_­t>.

В объекте этого шаблона класса хранятся:

• (3.1)

  bufptr - указатель на его нижележащий буфер потока байтов

• (3.2)

  cvtptr - указатель на выделенный объект преобразования (который освобождается при wbuffer_­convert уничтожении объекта)

• (3.3)

  cvtstate - объект состояния преобразования