| Альтернатива | Начальный | Альтернатива | Начальный | Альтернатива | Начальный |
| <% | { | and | && | and_eq | &= |
| %> | } | bitor | | | or_eq | |= |
| <: | [ | or | || | xor_eq | ^= |
| :> | ] | xor | ^ | not | ! |
| %: | # | compl | ~ | not_eq | != |
| %:%: | ## | bitand | & |
| 00A8 | 00AA | 00AD | 00AF | 00B2-00B5 |
| 00B7-00BA | 00BC-00BE | 00C0-00D6 | 00D8-00F6 | 00F8-00FF |
| 0100-167F | 1681-180D | 180F-1FFF | ||
| 200B-200D | 202A-202E | 203F-2040 | 2054 | 2060-206F |
| 2070-218F | 2460-24FF | 2776-2793 | 2C00-2DFF | 2E80-2FFF |
| 3004-3007 | 3021-302F | 3031-D7FF | ||
| F900-FD3D | FD40-FDCF | FDF0-FE44 | FE47-FFFD | |
| 10000-1FFFD | 20000-2FFFD | 30000-3FFFD | 40000-4FFFD | 50000-5FFFD |
| 60000-6FFFD | 70000-7FFFD | 80000-8FFFD | 90000-9FFFD | A0000-AFFFD |
| B0000-BFFFD | C0000-CFFFD | D0000-DFFFD | E0000-EFFFD |
| 0300-036F | 1DC0-1DFF | 20D0-20FF | FE20-FE2F |
| alignas | continue | friend | register | true |
| alignof | decltype | goto | reinterpret_cast | try |
| asm | default | if | return | typedef |
| auto | delete | inline | short | typeid |
| bool | do | int | signed | typename |
| break | double | long | sizeof | union |
| case | dynamic_cast | mutable | static | unsigned |
| catch | else | namespace | static_assert | using |
| char | enum | new | static_cast | virtual |
| char16_t | explicit | noexcept | struct | void |
| char32_t | export | nullptr | switch | volatile |
| class | extern | operator | template | wchar_t |
| const | false | private | this | while |
| constexpr | float | protected | thread_local | |
| const_cast | for | public | throw |
| and | and_eq | bitand | bitor | compl | not |
| not_eq | or | or_eq | xor | xor_eq |
| Суффикс | Десятичный литерал | Двоичный, восьмеричный или шестнадцатеричный литерал |
| никто | int | int |
| long int | unsigned int | |
| long long int | long int | |
| unsigned long int | ||
| long long int | ||
| unsigned long long int | ||
| u или U | unsigned int | unsigned int |
| unsigned long int | unsigned long int | |
| unsigned long long int | unsigned long long int | |
| l или L | long int | long int |
| long long int | unsigned long int | |
| long long int | ||
| unsigned long long int | ||
| Оба u или U | unsigned long int | unsigned long int |
| и l или L | unsigned long long int | unsigned long long int |
| ll или LL | long long int | long long int |
| unsigned long long int | ||
| Оба u или U | unsigned long long int | unsigned long long int |
| и ll или LL |
| новая линия | NL (LF) | \n |
| горизонтальная табуляция | HT | \t |
| вертикальная табуляция | VT | \v |
| Backspace | BS | \b |
| возврат каретки | CR | \r |
| подача формы | FF | \f |
| тревога | BEL | \a |
| обратная косая черта | \ | \\ |
| вопросительный знак | ? | \? |
| одинарная кавычка | ' | \' |
| двойная кавычка | " | \" |
| восьмеричное число | ооо | \ooo |
| шестнадцатеричный номер | ххх | \xhhh |
| Источник | Средства | Источник | Средства | Источник | Средства | |||
| u"a" | u"b" | u"ab" | U"a" | U"b" | U"ab" | L"a" | L"b" | L"ab" |
| u"a" | "b" | u"ab" | U"a" | "b" | U"ab" | L"a" | "b" | L"ab" |
| "a" | u"b" | u"ab" | "a" | U"b" | U"ab" | "a" | L"b" | L"ab" |
| no cv-qualifier | < | const |
| no cv-qualifier | < | volatile |
| no cv-qualifier | < | const volatile |
| const | < | const volatile |
| volatile | < | const volatile |
| Спецификатор (ы) | Тип |
| type-name | названный тип |
| simple-template-id | тип, как определено в [temp.names] |
| template-name | заполнитель для выводимого типа |
| символ | «Чар» |
| беззнаковый символ | «Беззнаковый символ» |
| подписанный символ | «Подписанный символ» |
| char16_t | «Char16_t» |
| char32_t | «Char32_t» |
| bool | «Булево» |
| беззнаковый | «Беззнаковое целое» |
| беззнаковое целое | «Беззнаковое целое» |
| подписано | «Int» |
| подписанный int | «Int» |
| int | «Int» |
| беззнаковый короткий int | «Короткое беззнаковое целое» |
| беззнаковый короткий | «Короткое беззнаковое целое» |
| беззнаковое длинное целое | «Беззнаковое длинное целое число» |
| беззнаковый длинный | «Беззнаковое длинное целое число» |
| беззнаковый длинный длинный int | «Беззнаковый длинный длинный int» |
| беззнаковый длинный длинный | «Беззнаковый длинный длинный int» |
| подписанный длинный int | «Длинный интервал» |
| подписан долго | «Длинный интервал» |
| подписанный длинный длинный int | «Длинный длинный интервал» |
| подписан долго | «Длинный длинный интервал» |
| длинный длинный int | «Длинный длинный интервал» |
| долго долго | «Длинный длинный интервал» |
| длинный интервал | «Длинный интервал» |
| длинный | «Длинный интервал» |
| подписанный короткий int | «Короткий интервал» |
| подписанный короткий | «Короткий интервал» |
| короткий int | «Короткий интервал» |
| короткая | «Короткий интервал» |
| wchar_t | «Wchar_t» |
| плавать | "плавать" |
| двойной | "двойной" |
| длинный двойной | «Длинный дубль» |
| пустота | "пустота" |
| авто | заполнитель для выводимого типа |
| decltype (авто) | заполнитель для выводимого типа |
| decltype ( expression) | тип, как определено ниже |
| Подпункт | Выражение | Как функция-член | Как функция, не являющаяся членом |
| [over.unary] | @a | (a).operator@ ( ) | operator@(a) |
| [over.binary] | a@b | (a).operator@ (b) | operator@(a, b) |
| [over.ass] | a=b | (a).operator= (b) | |
| [over.sub] | a[b] | (a).operator[](b) | |
| [over.ref] | a-> | (a).operator->( ) | |
| [over.inc] | a@ | (a).operator@ (0) | operator@(a, 0) |
| Преобразование | Категория | Классифицировать | Подпункт |
| Никаких преобразований не требуется | Личность | ||
| Lvalue-to-rvalue преобразование | [conv.lval] | ||
| Преобразование массива в указатель | Преобразование Lvalue | [conv.array] | |
| Преобразование функции в указатель | Точное совпадение | [conv.func] | |
| Квалификационные преобразования | [conv.qual] | ||
| Преобразование указателя на функцию | Квалификационная корректировка | [conv.fctptr] | |
| Интегральные акции | [conv.prom] | ||
| Продвижение с плавающей запятой | Продвижение | Продвижение | [conv.fpprom] |
| Интегральные преобразования | [conv.integral] | ||
| Преобразования с плавающей запятой | [conv.double] | ||
| Преобразования с плавающей запятой | [conv.fpint] | ||
| Преобразования указателей | Преобразование | Преобразование | [conv.ptr] |
| Указатель на преобразования членов | [conv.mem] | ||
| Логические преобразования | [conv.bool] |
| Оператор | Значение, когда пакет параметров пуст |
| && | true |
| || | false |
| , | void() |
| Пункт | Категория | |
| [language.support] | Библиотека языковой поддержки | |
| [diagnostics] | Библиотека диагностики | |
| [utilities] | Библиотека общих утилит | |
| [strings] | Библиотека строк | |
| [localization] | Библиотека локализации | |
| [containers] | Библиотека контейнеров | |
| [iterators] | Библиотека итераторов | |
| [algorithms] | Библиотека алгоритмов | |
| [numerics] | Библиотека чисел | |
| [input.output] | Библиотека ввода / вывода | |
| [re] | Библиотека регулярных выражений | |
| [atomics] | Библиотека атомарных операций | |
| [thread] | Библиотека поддержки потоков | |
| <algorithm> | <future> | <numeric> | <strstream> |
| <any> | <initializer_list> | <optional> | <system_error> |
| <array> | <iomanip> | <ostream> | <thread> |
| <atomic> | <ios> | <queue> | <tuple> |
| <bitset> | <iosfwd> | <random> | <type_traits> |
| <chrono> | <iostream> | <ratio> | <typeindex> |
| <codecvt> | <istream> | <regex> | <typeinfo> |
| <complex> | <iterator> | <scoped_allocator> | <unordered_map> |
| <condition_variable> | <limits> | <set> | <unordered_set> |
| <deque> | <list> | <shared_mutex> | <utility> |
| <exception> | <locale> | <sstream> | <valarray> |
| <execution> | <map> | <stack> | <variant> |
| <filesystem> | <memory> | <stdexcept> | <vector> |
| <forward_list> | <memory_resource> | <streambuf> | |
| <fstream> | <mutex> | <string> | |
| <functional> | <new> | <string_view> |
| <cassert> | <cinttypes> | <csignal> | <cstdio> | <cwchar> |
| <ccomplex> | <ciso646> | <cstdalign> | <cstdlib> | <cwctype> |
| <cctype> | <climits> | <cstdarg> | <cstring> | |
| <cerrno> | <clocale> | <cstdbool> | <ctgmath> | |
| <cfenv> | <cmath> | <cstddef> | <ctime> | |
| <cfloat> | <csetjmp> | <cstdint> | <cuchar> |
| abort_handler_s | mbstowcs_s | strncat_s | vswscanf_s |
| asctime_s | memcpy_s | strncpy_s | vwprintf_s |
| bsearch_s | memmove_s | strtok_s | vwscanf_s |
| constraint_handler_t | memset_s | swprintf_s | wcrtomb_s |
| ctime_s | printf_s | swscanf_s | wcscat_s |
| errno_t | qsort_s | tmpfile_s | wcscpy_s |
| fopen_s | RSIZE_MAX | TMP_MAX_S | wcsncat_s |
| fprintf_s | rsize_t | tmpnam_s | wcsncpy_s |
| freopen_s | scanf_s | vfprintf_s | wcsnlen_s |
| fscanf_s | set_constraint_handler_s | vfscanf_s | wcsrtombs_s |
| fwprintf_s | snprintf_s | vfwprintf_s | wcstok_s |
| fwscanf_s | snwprintf_s | vfwscanf_s | wcstombs_s |
| getenv_s | sprintf_s | vprintf_s | wctomb_s |
| gets_s | sscanf_s | vscanf_s | wmemcpy_s |
| gmtime_s | strcat_s | vsnprintf_s | wmemmove_s |
| ignore_handler_s | strcpy_s | vsnwprintf_s | wprintf_s |
| L_tmpnam_s | strerror_s | vsprintf_s | wscanf_s |
| localtime_s | strerrorlen_s | vsscanf_s | |
| mbsrtowcs_s | strlen_s | vswprintf_s |
| Подпункт | Заголовок (ы) | |
| <ciso646> | ||
| [support.types] | Типы | <cstddef> |
| [support.limits] | Свойства реализации | <cfloat> <limits> <climits> |
| [cstdint] | Целочисленные типы | <cstdint> |
| [support.start.term] | Начало и завершение | <cstdlib> |
| [support.dynamic] | Динамическое управление памятью | <new> |
| [support.rtti] | Идентификация типа | <typeinfo> |
| [support.exception] | Обработка исключений | <exception> |
| [support.initlist] | Списки инициализаторов | <initializer_list> |
| [support.runtime] | Другая поддержка во время выполнения | <cstdarg> |
| [meta] | Типовые черты | <type_traits> |
| [atomics] | Атомика | <atomic> |
| [depr.cstdalign.syn], [depr.cstdbool.syn] | Устаревшие заголовки | <cstdalign> <cstdbool> |
| Выражение | Тип возврата | Требование |
| a == b | конвертируемый в bool |
== является отношением эквивалентности, то есть обладает следующими свойствами:
|
| Выражение | Тип возврата | Требование |
| a < b | конвертируемый в bool | < это strict weak ordering relation |
| Выражение | Пост-условие |
| T t; | объект t инициализирован по умолчанию |
| T u{}; | объект u инициализирован значением или агрегатом |
|
T() T{} | объект типа T инициализируется значением или агрегатом |
| Выражение | Пост-условие |
| T u = rv; | u эквивалентно значению rv до постройки |
| T(rv) | T(rv) эквивалентно значению rv до постройки |
| rvсостояние не указано [ Note: rv должно все еще соответствовать требованиям библиотечного компонента, который его использует. Операции, перечисленные в этих требованиях, должны работать, как указано, независимо от того rv , были они перемещены или нет. ] — end note | |
| Выражение | Пост-условие |
| T u = v; | значение v не изменилось и эквивалентно u |
| T(v) | значение v не изменилось и эквивалентно T(v) |
| Выражение | Тип возврата | Возвращаемое значение | Пост-условие |
| t = rv | T& | t | Если t и rv не относятся к одному и тому же объекту, t эквивалентно значению rv до присвоения |
| rvсостояние не указано. [ Note: rv должен по-прежнему соответствовать требованиям библиотечного компонента, который его использует, независимо от того, относится ли он к одному t и rv тому же объекту или нет . Операции, перечисленные в этих требованиях, должны работать, как указано, независимо от того rv , были они перемещены или нет. ] — end note | |||
| Выражение | Тип возврата | Возвращаемое значение | Пост-условие |
| t = v | T& | t | t эквивалентно v, значение v не изменяется |
| Выражение | Пост-условие |
| u.~T() | Все ресурсы, принадлежащие владельцу u , возвращаются, никаких исключений не распространяется. |
| Выражение | Тип возврата | Операционная семантика |
|
P u(np); | Postconditions: u == nullptr | |
| P u = np; | ||
| P(np) | Postconditions: P(np) == nullptr | |
| t = np | P& | Postconditions: t == nullptr |
| a != b | контекстно конвертируемый в bool | !(a == b) |
| a == np | контекстно конвертируемый в bool | a == P() |
| np == a | ||
| a != np | контекстно конвертируемый в bool | !(a == np) |
| np != a |
| Выражение | Тип возврата | Требование |
| h(k) | size_t | Возвращаемое значение должно зависеть только от аргумента k на протяжении всей программы. [ Note: Таким образом, все вычисления выражения h(k) с одинаковым значением для k дают одинаковый результат для данного выполнения программы. ] [ Для двух разных значений и вероятность того, что и сравнить равные, должна быть очень мала и приближается . ] — end note Note: t1 t2 h(t1) h(t2) 1.0 / numeric_limits<size_t>::max() — end note |
| h(u) | size_t | Изменять не буду u. |
| Переменная | Определение |
| T, U, C | любой - cvнеквалифицированный тип объекта ( [basic.types]) |
| X | класс Allocator для типа T |
| Y | соответствующий класс Allocator для типа U |
| XX | тип allocator_traits<X> |
| YY | тип allocator_traits<Y> |
| a, a1, a2 | lvalues типа X |
| u | имя объявляемой переменной |
| b | значение типа Y |
| c | указатель типа, C* через который допустимо косвенное обращение |
| p | значение типа XX::pointer, полученное при вызове a1.allocate, где a1 == a |
| q | значение типа, XX::const_pointer полученное преобразованием из значения p. |
| w | значение типа, XX::void_pointer полученное преобразованием из значения p |
| x | значение типа, XX::const_void_pointer полученное преобразованием из значения q или значения w |
| y | значение типа, XX::const_void_pointer полученное преобразованием из значения результата YY::allocate, или значение типа (возможно const) std::nullptr_t. |
| n | значение типа XX::size_type. |
| Args | пакет параметров шаблона |
| args | пакет параметров функции с шаблоном Args&& |
| Выражение | Тип возврата | Утверждение / примечание | Дефолт |
| до / после состояния | |||
| X::pointer | T* | ||
| X::const_pointer | X::pointer конвертируется в X::const_pointer | pointer_traits<X::pointer>::rebind<const T> | |
| X::void_pointer Y::void_pointer | X::pointer конвертируется в X::void_pointer. X::void_pointer и Y::void_pointer однотипны. | pointer_traits<X::pointer>::rebind<void> | |
| X::const_void_pointer Y::const_void_pointer | X::pointer, X::const_pointerИ X::void_pointer могут быть конвертированы в X::const_void_pointer. X::const_void_pointer и Y::const_void_pointer однотипны. | pointer_traits<X::pointer>::rebind<const void> | |
| X::value_type | Идентично T | ||
| X::size_type | беззнаковый целочисленный тип | тип, который может представлять размер самого большого объекта в модели распределения. | make_unsigned_t<X::difference_type> |
| X::difference_type | знаковый целочисленный тип | тип, который может представлять разницу между любыми двумя указателями в модели распределения. | pointer_traits<X::pointer>::difference_type |
| typename X::template rebind<U>::other | Y | Для всех U (в том числе T) Y::template rebind<T>::other есть X. | См. Примечание A ниже. |
| *p | T& | ||
| *q | const T& | *q относится к тому же объекту, что и *p | |
| p->m | тип T::m | Requires: (*p).m четко определено. эквивалентно (*p).m | |
| q->m | тип T::m | Requires: (*q).m четко определено. эквивалентно (*q).m | |
| static_cast<X::pointer>(w) | X::pointer | static_cast<X::pointer>(w) == p | |
| static_cast<X::const_pointer>(x) | X::const_pointer | static_cast< X::const_pointer>(x) == q | |
| pointer_traits<X::pointer>::pointer_to(r) | X::pointer | ||
| a.allocate(n) | X::pointer | Память выделяется для n объектов типа, T но объекты не создаются. allocate может вызвать соответствующее исключение. 175 [ Note: Если n == 0, возвращаемое значение не указано. ] — end note | |
| a.allocate(n, y) | X::pointer | То же, что и a.allocate(n). Использование y не указано, но оно предназначено для помощи в местности. | a.allocate(n) |
| a.deallocate(p,n) | (не используется) |
Requires: p должен быть значением, возвращенным более ранним вызовом allocate , который не был аннулирован промежуточным вызовом deallocate. n должен соответствовать значению, переданному allocate для получения этой памяти. Throws: Ничего такого. | |
| a.max_size() | X::size_type | наибольшее значение, которое может быть значимо передано в X::allocate() | numeric_limits<size_type>::max() / sizeof(value_type) |
| a1 == a2 | bool | возвращается true только в том случае, если память, выделенная каждым из них, может быть освобождена через другую. operator== должен быть рефлексивным, симметричным и транзитивным и не должен выходить через исключение. | |
| a1 != a2 | bool | такой же как !(a1 == a2) | |
| a == b | bool | такой же как a == Y::rebind<T>::other(b) | |
| a != b | bool | такой же как !(a == b) | |
| X u(a); X u = a; |
Не должен выходить из-за исключения. Postconditions: u == a | ||
| X u(b); |
Не должен выходить из-за исключения. Postconditions: Y(u) == b, u == X(b) | ||
| X u(std::move(a)); X u = std::move(a); |
Не должен выходить из-за исключения. Postconditions: u равно предыдущему значению a. | ||
| X u(std::move(b)); |
Не должен выходить из-за исключения. Postconditions: u равно предыдущему значению X(b). | ||
| a.construct(c, args) | (не используется) | Effects: Создает объект типа C в c | ::new ((void*)c) C(forward<Args>(args)...) |
| a.destroy(c) | (не используется) | Effects: Уничтожает объект на c | c->~C() |
| a.select_on_container_copy_construction() | X | Обычно возвращает либо, a либо X() | return a; |
| X::propagate_on_container_copy_assignment | Идентичен или производный от true_type или false_type | true_type только если распределитель типа X должен быть скопирован, когда клиентскому контейнеру назначено копирование. См. Примечание B ниже. | false_type |
| X::propagate_on_container_move_assignment | Идентичен или производный от true_type или false_type | true_type только в том случае, если распределитель типа X должен быть перемещен при назначении перемещения клиентскому контейнеру. См. Примечание B ниже. | false_type |
| X::propagate_on_- container_swap | Идентичен или производный от true_type или false_type | true_type только если распределитель типа X должен быть заменен при замене клиентского контейнера. См. Примечание B ниже. | false_type |
| X::is_always_equal | Идентичен или производный от true_type или false_type | true_type только тогда , когда выражение a1 == a2 гарантированно будет true для любых двух (возможно const) значений a1, a2 типа X. | is_empty<X>::type |
| Подпункт | Заголовок (ы) | |
| [support.types] | Общие определения | <cstddef> |
| <cstdlib> | ||
| [support.limits] | Свойства реализации | <limits> |
| <climits> | ||
| <cfloat> | ||
| [cstdint] | Целочисленные типы | <cstdint> |
| [support.start.term] | Начало и завершение | <cstdlib> |
| [support.dynamic] | Динамическое управление памятью | <new> |
| [support.rtti] | Идентификация типа | <typeinfo> |
| [support.exception] | Обработка исключений | <exception> |
| [support.initlist] | Списки инициализаторов | <initializer_list> |
| [support.runtime] | Другая поддержка во время выполнения | <csignal> |
| <csetjmp> | ||
| <cstdarg> | ||
| <cstdlib> | ||
| Подпункт | Заголовок (ы) | |
| [std.exceptions] | Классы исключений | <stdexcept> |
| [assertions] | Утверждения | <cassert> |
| [errno] | Номера ошибок | <cerrno> |
| [syserr] | Поддержка системных ошибок | <system_error> |
| Подпункт | Заголовок (ы) | |
| [utility] | Компоненты утилиты | <utility> |
| [intseq] | Целочисленные последовательности во время компиляции | <utility> |
| [pairs] | Пары | <utility> |
| [tuple] | Кортежи | <tuple> |
| [optional] | Необязательные объекты | <optional> |
| [variant] | Варианты | <variant> |
| [any] | Хранение любого типа | <any> |
| [bitset] | Последовательности битов фиксированного размера | <bitset> |
| [memory] | объем памяти | <memory> |
| <cstdlib> | ||
| [smartptr] | Умные указатели | <memory> |
| [mem.res] | Ресурсы памяти | <memory_resource> |
| [allocator.adaptor] | Распределители с заданной областью | <scoped_allocator> |
| [function.objects] | Функциональные объекты | <functional> |
| [meta] | Типовые черты | <type_traits> |
| [ratio] | Рациональная арифметика во время компиляции | <ratio> |
| [time] | Утилиты времени | <chrono> |
| <ctime> | ||
| [type.index] | Индексы типов | <typeindex> |
| [execpol] | Политики исполнения | <execution> |
| *this содержит значение | *this не содержит значения | |
| rhs содержит значение | присваивает *rhs содержащееся значение | инициализирует значение , содержащееся как если прямая не-список-инициализацию объекта типа T с *rhs |
| rhs не содержит значения | уничтожает содержащееся значение, вызывая val->T::~T() | нет эффекта |
| *this содержит значение | *this не содержит значения | |
| rhs содержит значение | присваивает std::move(*rhs) содержащееся значение | инициализирует значение , содержащееся как если прямая не-список-инициализацию объекта типа T с std::move(*rhs) |
| rhs не содержит значения | уничтожает содержащееся значение, вызывая val->T::~T() | нет эффекта |
| *this содержит значение | *this не содержит значения | |
| rhs содержит значение | присваивает *rhs содержащееся значение | инициализирует значение , содержащееся как если прямая не-список-инициализацию объекта типа T с *rhs |
| rhs не содержит значения | уничтожает содержащееся значение, вызывая val->T::~T() | нет эффекта |
| *this содержит значение | *this не содержит значения | |
| rhs содержит значение | присваивает std::move(*rhs) содержащееся значение | инициализирует значение , содержащееся как если прямая не-список-инициализацию объекта типа T с std::move(*rhs) |
| rhs не содержит значения | уничтожает содержащееся значение, вызывая val->T::~T() | нет эффекта |
| *this содержит значение | *this не содержит значения | |
| rhs содержит значение | звонки swap(*(*this), *rhs) | инициализирует содержащееся значение, *this как если бы напрямую без списка инициализирует объект типа T с выражением std::move(*rhs), за которым следует rhs.val->T::~T(); постусловие - это то, что *this содержит значение и rhs не содержит значения |
| rhs не содержит значения | инициализирует содержащееся значение, rhs как если бы напрямую без списка инициализирует объект типа T с выражением std::move(*(*this)), за которым следует val->T::~T(); постусловие - это то, *this что не содержит значения и rhs содержит значение | нет эффекта |
| Шаблон | Состояние | Комментарии |
|
template <class T> struct is_void; | T является void | |
|
template <class T> struct is_null_pointer; | T есть nullptr_t ( [basic.fundamental]) | |
|
template <class T> struct is_integral; | T является integral type | |
|
template <class T> struct is_floating_point; | T это floating-point type | |
|
template <class T> struct is_array; | T является типом массива ( [basic.compound]) известной или неизвестной степени | Шаблон класса array не является типом массива. |
|
template <class T> struct is_pointer; | T это pointer type | Включает указатели на функции, но не указатели на нестатические члены. |
|
template <class T> struct is_lvalue_reference; | T является lvalue reference type | |
|
template <class T> struct is_rvalue_reference; | T является rvalue reference type | |
|
template <class T> struct is_member_object_pointer; | T указатель на нестатический член данных | |
|
template <class T> struct is_member_function_pointer; | T указатель на нестатическую функцию-член | |
|
template <class T> struct is_enum; | T это перечислимый тип ( [basic.compound]) | |
|
template <class T> struct is_union; | T тип объединения ( [basic.compound]) | |
|
template <class T> struct is_class; | T тип класса, не являющегося объединением ( [basic.compound]) | |
|
template <class T> struct is_function; | T это функция type ( [basic.compound]) |
| Шаблон | Состояние | Комментарии |
|
template <class T> struct is_reference; | T ссылка lvalue или ссылка rvalue | |
|
template <class T> struct is_arithmetic; | T является arithmetic type | |
|
template <class T> struct is_fundamental; | T это fundamental type | |
|
template <class T> struct is_object; | T является object type | |
|
template <class T> struct is_scalar; | T это scalar type | |
|
template <class T> struct is_compound; | T это compound type | |
|
template <class T> struct is_member_pointer; | T является указателем на нестатический член данных или нестатическую функцию-член |
| Шаблон | Состояние | Предварительные условия |
|
template <class T> struct is_const; | T является const-qualified | |
| template <class T> struct is_volatile; | T является volatile-qualified | |
|
template <class T> struct is_trivial; | T это trivial type | remove_all_extents_t<T> должен быть полным типом или cv void. |
| template <class T> struct is_trivially_copyable; | T это trivially copyable type | remove_all_extents_t<T> должен быть полным типом или cv void. |
| template <class T> struct is_standard_layout; | T это standard-layout type | remove_all_extents_t<T> должен быть полным типом или cv void. |
| template <class T> struct is_pod; | T это POD type | remove_all_extents_t<T> должен быть полным типом или cv void. |
| template <class T> struct is_empty; | T - это тип класса, но не тип объединения, без нестатических членов данных, кроме битовых полей длины 0, без виртуальных функций-членов, без виртуальных базовых классов и без базового класса, B для которого is_empty_v<B> есть false. | Если T тип класса, T не являющийся объединением, должен быть полным типом. |
| template <class T> struct is_polymorphic; | T это polymorphic class | Если T тип класса, T не являющийся объединением, должен быть полным типом. |
| template <class T> struct is_abstract; | T является abstract class | Если T тип класса, T не являющийся объединением, должен быть полным типом. |
| template <class T> struct is_final; | T - это тип класса, отмеченный class-virt-specifier final (Условием [class]). [ Note: Объединение - это тип класса, который можно пометить значком final. ] — end note | Если T это тип класса, он T должен быть полным типом. |
| template <class T> struct is_aggregate; | T является агрегатным типом ( [dcl.init.aggr]) | remove_all_extents_t<T> должен быть полным типом или cv void. |
| template <class T> struct is_signed; | Если is_arithmetic_v<T> есть true, тот же результат, что и T(-1) < T(0); иначе, false | |
| template <class T> struct is_unsigned; | Если is_arithmetic_v<T> есть true, тот же результат, что и T(0) < T(-1); иначе, false | |
| template <class T, class... Args> struct is_constructible; | Для типа функции T или для cv void типа T, is_constructible_v<T, Args...> в falseпротивном случае see below | T и все типы в пакете параметров Args должны быть полными типами cv voidили массивами с неизвестной границей. |
| template <class T> struct is_default_constructible; | is_constructible_v<T> есть true. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct is_copy_constructible; | Для a referenceable type Tтот же результат, что is_constructible_v<T, const T&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct is_move_constructible; | Для ссылочного типа Tтот же результат, что is_constructible_v<T, T&&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T, class U> struct is_assignable; | Выражение declval<T>() = declval<U>() правильно сформировано, если рассматривать его как unevaluated operand. Проверка доступа выполняется, как если бы в контексте, не связанном с T и U. Учитывается только действительность непосредственного контекста выражения присваивания. [ Note: Компиляция выражения может привести к побочным эффектам, таким как создание экземпляров специализаций шаблонов классов и специализаций шаблонов функций, создание неявно определенных функций и т. Д. Такие побочные эффекты не относятся к «непосредственному контексту» и могут привести к неправильному формированию программы. ] — end note | T и U должны быть полными типами cv voidили массивами с неизвестной границей. |
| template <class T> struct is_copy_assignable; | Для ссылочного типа Tтот же результат, что is_assignable_v<T&, const T&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct is_move_assignable; | Для ссылочного типа Tтот же результат, что is_assignable_v<T&, T&&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T, class U> struct is_swappable_with; | Каждое выражение swap(declval<T>(), declval<U>()) и swap(declval<U>(), declval<T>()) имеет правильный формат, если рассматривать его как unevaluated operand контекст разрешения перегрузки для заменяемых значений ( [swappable.requirements]). Проверка доступа выполняется, как если бы в контексте, не связанном с T и U. Учитывается только действительность непосредственного контекста swap выражений. [ Note: Компиляция выражений может привести к побочным эффектам, таким как создание экземпляров специализаций шаблонов классов и специализаций шаблонов функций, создание неявно определенных функций и т. Д. Такие побочные эффекты не относятся к «непосредственному контексту» и могут привести к неправильному формированию программы. ] — end note | T и U должны быть полными типами cv voidили массивами с неизвестной границей. |
| template <class T> struct is_swappable; | Для ссылочного типа Tтот же результат, что is_swappable_with_v<T&, T&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct is_destructible; | Либо T это ссылочный тип, либо T полный тип объекта, для которого выражение declval<U&>().~U() правильно сформировано при обработке как unevaluated operand, где U есть remove_all_extents<T>. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T, class... Args> struct is_trivially_constructible; |
is_constructible_v<T, Args...> is, true и известно, что определение переменной for is_constructible, как определено ниже, не вызывает никаких нетривиальных операций ( [basic.types], [special]). | T и все типы в пакете параметров Args должны быть полными типами cv voidили массивами с неизвестной границей. |
| template <class T> struct is_trivially_default_constructible; | is_trivially_constructible_v<T> есть true. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct is_trivially_copy_constructible; | Для ссылочного типа Tтот же результат, что is_trivially_constructible_v<T, const T&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct is_trivially_move_constructible; | Для ссылочного типа Tтот же результат, что is_trivially_constructible_v<T, T&&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T, class U> struct is_trivially_assignable; | is_assignable_v<T, U> есть, true и известно, что присвоение, как определено is_assignable, не вызывает никакой нетривиальной операции ( [basic.types], [special]). | T и U должны быть полными типами cv voidили массивами с неизвестной границей. |
| template <class T> struct is_trivially_copy_assignable; | Для ссылочного типа Tтот же результат, что is_trivially_assignable_v<T&, const T&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct is_trivially_move_assignable; | Для ссылочного типа Tтот же результат, что is_trivially_assignable_v<T&, T&&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct is_trivially_destructible; | is_destructible_v<T> есть true и указанный деструктор, как известно, тривиален. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T, class... Args> struct is_nothrow_constructible; | is_constructible_v<T, Args...> is, true а определение переменной for is_constructible, как определено ниже, не генерирует никаких исключений ( [expr.unary.noexcept]). | T и все типы в пакете параметров Args должны быть полными типами cv voidили массивами с неизвестной границей. |
| template <class T> struct is_nothrow_default_constructible; | is_nothrow_constructible_v<T> есть true. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct is_nothrow_copy_constructible; | Для ссылочного типа Tтот же результат, что is_nothrow_constructible_v<T, const T&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct is_nothrow_move_constructible; | Для ссылочного типа Tтот же результат, что is_nothrow_constructible_v<T, T&&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T, class U> struct is_nothrow_assignable; | is_assignable_v<T, U> is, true и известно, что присвоение не генерирует никаких исключений ( [expr.unary.noexcept]). | T и U должны быть полными типами cv voidили массивами с неизвестной границей. |
| template <class T> struct is_nothrow_copy_assignable; | Для ссылочного типа Tтот же результат, что is_nothrow_assignable_v<T&, const T&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct is_nothrow_move_assignable; | Для ссылочного типа Tтот же результат, что is_nothrow_assignable_v<T&, T&&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T, class U> struct is_nothrow_swappable_with; | is_swappable_with_v<T, U> is, true и известно, что каждое swap выражение определения не is_swappable_with<T, U> вызывает никаких исключений ( [expr.unary.noexcept]). | T и U должны быть полными типами cv voidили массивами с неизвестной границей. |
| template <class T> struct is_nothrow_swappable; | Для ссылочного типа Tтот же результат, что is_nothrow_swappable_with_v<T&, T&>и в противном случае false. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct is_nothrow_destructible; | is_destructible_v<T> is, true и известно, что указанный деструктор не генерирует никаких исключений ( [expr.unary.noexcept]). | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| template <class T> struct has_virtual_destructor; | T есть виртуальный destructor | Если T тип класса, T не являющийся объединением, должен быть полным типом. |
| template <class T> struct has_unique_object_representations; | Для типа массива Tтот же результат, что has_unique_object_representations_v<remove_all_extents_t<T>>и в противном случае see below. | T должен быть полным типом cv voidили массивом с неизвестной границей. |
| Шаблон | Ценить |
|
template <class T> struct alignment_of; |
alignof(T). Requires: alignof(T) должно быть допустимым выражением ( [expr.alignof]) |
| template <class T> struct rank; | Если T именует тип массива, целочисленное значение, представляющее количество измерений T; в противном случае 0. |
| template <class T, unsigned I = 0> struct extent; | Если T это не тип массива, или если его ранг меньше или равен I, или если он I равен 0 и T имеет тип «массив с неизвестной границей U», то 0; в противном случае граница ( [dcl.array]) I'го измерения T, где индексирование отсчитывается от I нуля |
| Шаблон | Состояние | Комментарии |
|
template <class T, class U> struct is_same; | T и U назовите тот же тип с одинаковыми CV-квалификациями | |
| template <class Base, class Derived> struct is_base_of; | Base является базовым классом Derived (Clause [class.derived]) без учета cv-квалификаторов или Base и Derived не является объединением и называет один и тот же тип класса без учета cv-квалификаторов | Если Base и Derived являются типами класса без объединения и, возможно, не являются версиями одного и того же типа с квалификацией cv, Derived должен быть полным типом. [ Note: Базовые классы, которые являются частными, защищенными или неоднозначными, тем не менее, являются базовыми классами. ] — end note |
| template <class From, class To> struct is_convertible; | see below | From и To должны быть полными типами, массивами с неизвестной границей или cv void типами. |
| template <class Fn, class... ArgTypes> struct is_invocable; | Выражение INVOKE(declval<Fn>(), declval<ArgTypes>()...) правильно сформировано, когда рассматривается как неоцененный операнд | Fn и все типы в пакете параметров ArgTypes должны быть полными типами cv voidили массивами с неизвестной границей. |
| template <class R, class Fn, class... ArgTypes> struct is_invocable_r; | Выражение INVOKE<R>(declval<Fn>(), declval<ArgTypes>()...) правильно сформировано, когда рассматривается как неоцененный операнд | Fn,, Rи все типы в пакете параметров ArgTypes должны быть полными типами cv voidили массивами с неизвестной границей. |
| template <class Fn, class... ArgTypes> struct is_nothrow_invocable; |
is_invocable_v< Fn, ArgTypes...> есть true и выражение, INVOKE(declval<Fn>(), declval<ArgTypes>()...) как известно, не генерирует никаких исключений | Fn и все типы в пакете параметров ArgTypes должны быть полными типами cv voidили массивами с неизвестной границей. |
| template <class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r; |
is_invocable_r_v< R, Fn, ArgTypes...> есть true и выражение, INVOKE<R>(declval<Fn>(), declval<ArgTypes>()...) как известно, не генерирует никаких исключений | Fn,, Rи все типы в пакете параметров ArgTypes должны быть полными типами cv voidили массивами с неизвестной границей. |
| Шаблон | Комментарии |
|
template <class T> struct remove_reference; | Если T имеет тип «ссылка на T1», тогда type имена typedef члена T1; в противном случае - type имена T. |
| template <class T> struct add_lvalue_reference; | Если T имена a, referenceable type то член typedef type names T&; в противном случае - type имена T. [ Note: Это правило отражает семантику свертывания ссылок ( [dcl.ref]). ] — end note |
| template <class T> struct add_rvalue_reference; | Если T именует Referenceable типа , то члены ЬурейеГо type имен T&&; в противном случае - type имена T. [ Note: Это правило отражает семантику свертывания ссылок ( [dcl.ref]). Например, когда тип T называет тип T1&, этот тип add_rvalue_reference_t<T> не является ссылкой rvalue. ] — end note |
| Шаблон | Комментарии |
|
template <class T> struct make_signed; |
Если T именует a (возможно, cv-квалифицированным),
signed integer type тогда typedef члена
type называет тип T; в противном случае, если T именуется (возможно, cv-квалифицированный) беззнаковый целочисленный тип, тогда type именуется соответствующий знаковый целочисленный тип с теми же cv-квалификаторами, что и T; в противном случае, type именует знаковое целое типа с , smallest
rank для которых
sizeof(T) == sizeof(type), с тем же CV-определителями как T. Requires: T должен быть (возможно, cv-квалифицированным) целочисленным типом или перечислением, но не bool типом. |
| template <class T> struct make_unsigned; |
Если T именует a (возможно, cv-квалифицированным),
unsigned integer type тогда typedef члена
type называет тип T; в противном случае, если T именуется (возможно, cv-квалифицированный) целочисленный тип со знаком, тогда type именуется соответствующий беззнаковый целочисленный тип с теми же cv-квалификаторами, что и T; в противном случае, type называют целое число без знака типа с , smallest
rank для которого
sizeof(T) == sizeof(type), с тем же CV-классификаторами как T. Requires: T должен быть (возможно, cv-квалифицированным) целочисленным типом или перечислением, но не bool типом. |
| Шаблон | Комментарии |
|
template <class T> struct remove_pointer; | Если T имеет тип «(возможно , резюме квалифицированное) указатель T1» затем член ЬурейеГо type имен T1; в противном случае это имена T. |
| template <class T> struct add_pointer; | Если T называет тип referenceable type или cv void тип, то член typedef type называет тот же тип, что и remove_reference_t<T>*; в противном случае - type имена T. |
| Шаблон | Комментарии |
|
template <size_t Len, size_t Align = default-alignment> struct aligned_storage; |
Значение default-alignment должно быть наиболее строгим требованием к выравниванию для любого типа объекта C ++, размер которого не превышает Len ( [basic.types]). Член typedef type должен быть типом POD, подходящим для использования в качестве неинициализированного хранилища для любого объекта, размер которого не больше, Len а выравнивание является делителем Align. Requires: Len не должно быть нулевым. Align должен быть равен alignof(T) для некоторого типа T или to default-alignment. |
| template <size_t Len, class... Types> struct aligned_union; |
Элемент typedef type должен быть типом POD, подходящим для использования в качестве неинициализированного хранилища для любого объекта, тип которого указан в Types; его размер должен быть не менее Len. Статический член alignment_value
должен быть интегральной константой типа size_t , значение которого является самым строгим выравниванием из всех типов, перечисленных в Types. Requires: Предусмотрен хотя бы один тип. |
| template <class T> struct decay; | Пусть U будет remove_reference_t<T>. Если is_array_v<U> есть true, то член typedef type должен быть равен remove_extent_t<U>*. Если is_function_v<U> есть true, то член typedef type должен быть равен add_pointer_t<U>. В противном случае typedef члена type равен remove_cv_t<U>. [ Note: Это поведение похоже на lvalue-to-rvalue, array-to-pointerи function-to-pointer преобразование применяется , когда выражение - значения используется в качестве RValue, но и полоска cv-qualifiers от типов классов , с тем чтобы более точно моделями по значению передачи аргументов. ] — end note |
| template <bool B, class T = void> struct enable_if; | Если B есть true, то член typedef type должен быть равен T; в противном случае член не должен быть type. |
| template <bool B, class T,
class F> struct conditional; | Если B есть true, то член typedef type должен быть равен T. Если B есть false, то член typedef type должен быть равен F. |
| template <class... T> struct common_type; | Если этот признак не является специализированным (как указано в примечании B ниже), член type должен быть определен или опущен, как указано в примечании A ниже. Если он опущен, член не должен быть type. Каждый тип в пакете параметров T должен быть полным cv voidили массивом с неизвестными границами. |
| template <class T> struct underlying_type; |
Элемент typedef type называет базовый тип T. Requires: T должен быть полным enumeration type |
| template <class Fn, class... ArgTypes> struct invoke_result; |
Если выражение INVOKE(declval<Fn>(), declval<ArgTypes>()...)
правильно сформировано при обработке как выражение unevaluated operand, typedef члена type называет тип
decltype(INVOKE(declval<Fn>(), declval<ArgTypes>()...)); в противном случае член не должен быть type. Проверка доступа выполняется, как если бы в контексте, не связанном с Fn и
ArgTypes. Учитывается только действительность непосредственного контекста выражения. [ Note:
Компиляция выражения может привести к побочным эффектам, таким как создание экземпляров специализаций шаблонов классов и специализаций шаблонов функций, создание неявно определенных функций и т. Д. Такие побочные эффекты не относятся к «непосредственному контексту» и могут привести к неправильному формированию программы.
] и все типы в пакете параметров должны быть полными типами или массивами с неизвестной границей. — end note Requires: Fn ArgTypes cv void |
| Тип | Значение X | Значение Y |
| ratio_add<R1, R2> | R1::num * R2::den + | R1::den * R2::den |
| R2::num * R1::den | ||
| ratio_subtract<R1, R2> | R1::num * R2::den - | R1::den * R2::den |
| R2::num * R1::den | ||
| ratio_multiply<R1, R2> | R1::num * R2::num | R1::den * R2::den |
| ratio_divide<R1, R2> | R1::num * R2::den | R1::den * R2::num |
| Выражение | Тип возврата | Операционная семантика |
| C1::rep | Арифметический тип или класс, имитирующий арифметический тип | Тип представления C1::duration. |
| C1::period | специализация ratio | Период тика часов в секундах. |
| C1::duration | chrono::duration<C1::rep, C1::period> | duration Тип часов. |
| C1::time_point | chrono::time_point<C1> или chrono::time_point<C2, C1::duration> | time_point Тип часов. C1 и C2 будет относиться к той же эпохе. |
| C1::is_steady | const bool | true если t1 <= t2 всегда, true а время между тактами часов постоянно, в противном случае false. |
| C1::now() | C1::time_point | Возвращает time_point объект, представляющий текущий момент времени. |
| Подпункт | Заголовок (ы) | |
| [char.traits] | Черты характера | <string> |
| [string.classes] | Строковые классы | <string> |
| [string.view] | Классы строковых представлений | <string_view> |
| <cctype> | ||
| <cwctype> | ||
| [c.strings] | Утилиты для последовательностей с нулевым завершением | <cstring> |
| <cwchar> | ||
| <cstdlib> | ||
| <cuchar> | ||
| Выражение | Тип возврата | Утверждение / примечание | Сложность |
| до / после состояния | |||
| X::char_type | charT | (описано в [char.traits.typedefs]) | время компиляции |
| X::int_type | (описано в [char.traits.typedefs]) | время компиляции | |
| X::off_type | (описано в [char.traits.typedefs]) | время компиляции | |
| X::pos_type | (описано в [char.traits.typedefs]) | время компиляции | |
| X::state_type | (описано в [char.traits.typedefs]) | время компиляции | |
| X::eq(c,d) | bool | Returns: следует ли c рассматривать как равное d. | постоянный |
| X::lt(c,d) | bool | Returns: следует ли c рассматривать как меньшее, чем d. | постоянный |
| X::compare(p,q,n) | int | Returns: 0 если для каждого i в [0,n), X::eq(p[i],q[i]) есть true; иначе, отрицательное значение , если для некоторых j ин [0,n), X::lt(p[j],q[j]) это true и для каждого i дюйма [0,j) X::eq(p[i],q[i]) является true; иначе положительное значение. | линейный |
| X::length(p) | size_t | Returns: самый маленький i такой что X::eq(p[i],charT()) есть true. | линейный |
| X::find(p,n,c) | const X::char_type* | Returns: наименьшее q в [p,p+n) таком, то X::eq(*q,c) есть true, в противном случае ноль. | линейный |
| X::move(s,p,n) | X::char_type* |
для каждого i в [0,n), выполняет X::assign(s[i],p[i]). Копирует правильно даже там, где диапазоны [p,p+n) и [s,s+n) перекрываются. Returns: s. | линейный |
| X::copy(s,p,n) | X::char_type* |
Requires: p не в [s,s+n). Returns: s. для каждого i в [0,n), выполняет X::assign(s[i],p[i]). | линейный |
| X::assign(r,d) | (не используется) | назначает r=d. | постоянный |
| X::assign(s,n,c) | X::char_type* |
для каждого i в [0,n), выполняет
X::assign(s[i],c). Returns: s. | линейный |
| X::not_eof(e) | int_type | Returns: e если X::eq_int_type(e,X::eof()) есть false, в противном случае такое значение f , которое X::eq_int_type(f,X::eof()) есть false. | постоянный |
| X::to_char_type(e) | X::char_type | Returns: если для некоторых c, X::eq_int_type(e,X::to_int_type(c)) это true, c; иначе какое-то неопределенное значение. | постоянный |
| X::to_int_type(c) | X::int_type | Returns: некоторая ценность e, ограниченная определениями to_char_type и eq_int_type. | постоянный |
| X::eq_int_type(e,f) | bool | Returns: для всех c и d, X::eq(c,d) равно X::eq_int_type(X::to_int_type(c), X::to_int_type(d)); в противном случае выдает true if e и f обе копии X::eof(); в противном случае уступает, false если одно из e и f является копией, X::eof() а другое - нет; в противном случае значение не указано. | постоянный |
| X::eof() | X::int_type | Returns: такое значение e , которое X::eq_int_type(e,X::to_int_type(c)) есть false для всех значений c. | постоянный |
| Элемент | Ценить |
| data() | ненулевой указатель, который можно копировать и к нему можно добавить 0 |
| size() | 0 |
| capacity() | неуказанное значение |
| Элемент | Ценить |
| data() | указывает на первый элемент выделенной копии массива, на первый элемент которого указывает str.data() |
| size() | str.size() |
| capacity() | значение, по крайней мере, такое большое, как size() |
| Элемент | Ценить |
| data() | указывает на первый элемент выделенной копии rlen последовательных элементов строки, управляемой str начиная с позиции pos |
| size() | rlen |
| capacity() | значение, по крайней мере, такое большое, как size() |
| Элемент | Ценить |
| data() | указывает на первый элемент выделенной копии массива, на первый элемент которого указывает s |
| size() | n |
| capacity() | значение, по крайней мере, такое большое, как size() |
| Элемент | Ценить |
| data() | указывает на первый элемент выделенной копии массива, на первый элемент которого указывает s |
| size() | traits::length(s) |
| capacity() | значение, по крайней мере, такое большое, как size() |
| Элемент | Ценить |
| data() | указывает на первый элемент выделенного массива n элементов, каждый из которых хранит начальное значение c |
| size() | n |
| capacity() | значение, по крайней мере, такое большое, как size() |
| Элемент | Ценить |
| data() | указывает на первый элемент выделенной копии массива, на первый элемент которого указывает исходное значение str.data(). |
| size() | первоначальная стоимость str.size() |
| capacity() | значение, по крайней мере, такое большое, как size() |
| get_allocator() | alloc |
| Элемент | Ценить |
| data() | указывает на первый элемент выделенной копии массива, на первый элемент которого указывает str.data() |
| size() | str.size() |
| capacity() | значение, по крайней мере, такое большое, как size() |
| Состояние | Возвращаемое значение |
| size() < sv.size() | < 0 |
| size() == sv.size() | 0 |
| size() > sv.size() | > 0 |
| Элемент | Ценить |
| data_ | str |
| size_ | traits::length(str) |
| Элемент | Ценить |
| data_ | str |
| size_ | len |
| Состояние | Возвращаемое значение |
| size() < str.size() | < 0 |
| size() == str.size() | 0 |
| size() > str.size() | > 0 |
| Выражение | Эквивалентно |
| t == sv | S(t) == sv |
| sv == t | sv == S(t) |
| t != sv | S(t) != sv |
| sv != t | sv != S(t) |
| t < sv | S(t) < sv |
| sv < t | sv < S(t) |
| t > sv | S(t) > sv |
| sv > t | sv > S(t) |
| t <= sv | S(t) <= sv |
| sv <= t | sv <= S(t) |
| t >= sv | S(t) >= sv |
| sv >= t | sv >= S(t) |
| Подпункт | Заголовок (ы) | |
| [locales] | Locales | <locale> |
| [locale.categories] | Стандартные locale категории | |
| [c.locales] | Языковые стандарты библиотеки C | <clocale> |
| Категория | Включает грани |
| сопоставлять | collate<char>, collate<wchar_t> |
| ctype | ctype<char>, ctype<wchar_t> |
| codecvt<char, char, mbstate_t> | |
| codecvt<char16_t, char, mbstate_t> | |
| codecvt<char32_t, char, mbstate_t> | |
| codecvt<wchar_t, char, mbstate_t> | |
| денежный | moneypunct<char>, moneypunct<wchar_t> |
| moneypunct<char, true>, moneypunct<wchar_t, true> | |
| money_get<char>, money_get<wchar_t> | |
| money_put<char>, money_put<wchar_t> | |
| числовой | numpunct<char>, numpunct<wchar_t> |
| num_get<char>, num_get<wchar_t> | |
| num_put<char>, num_put<wchar_t> | |
| время | time_get<char>, time_get<wchar_t> |
| time_put<char>, time_put<wchar_t> | |
| Сообщения | messages<char>, messages<wchar_t> |
| Категория | Включает грани |
| сопоставлять | collate_byname<char>, collate_byname<wchar_t> |
| ctype | ctype_byname<char>, ctype_byname<wchar_t> |
| codecvt_byname<char, char, mbstate_t> | |
| codecvt_byname<char16_t, char, mbstate_t> | |
| codecvt_byname<char32_t, char, mbstate_t> | |
| codecvt_byname<wchar_t, char, mbstate_t> | |
| денежный | moneypunct_byname<char, International> |
| moneypunct_byname<wchar_t, International> | |
| money_get<C, InputIterator> | |
| money_put<C, OutputIterator> | |
| числовой | numpunct_byname<char>, numpunct_byname<wchar_t> |
| num_get<C, InputIterator>, num_put<C, OutputIterator> | |
| время | time_get<char, InputIterator> |
| time_get_byname<char, InputIterator> | |
| time_get<wchar_t, InputIterator> | |
| time_get_byname<wchar_t, InputIterator> | |
| time_put<char, OutputIterator> | |
| time_put_byname<char, OutputIterator> | |
| time_put<wchar_t, OutputIterator> | |
| time_put_byname<wchar_t, OutputIterator> | |
| Сообщения | messages_byname<char>, messages_byname<wchar_t> |
| Ценить | Имея в виду |
| ok | завершил преобразование |
| partial | не все исходные символы преобразованы |
| error | обнаружил символ, [from, from_end) который не может преобразовать |
| noconv | internT и externT одного типа, а входная последовательность идентична преобразованной последовательности |
| Ценить | Имея в виду |
| ok | завершил последовательность |
| partial | пространство для более чем to_end - to целевых элементов требовалось для завершения последовательности с учетом значения state |
| error | произошла неопределенная ошибка |
| noconv | для этого не требуется прекращения state_type |
| Состояние | stdio эквивалент |
| basefield == oct | %o |
| basefield == hex | %X |
| basefield == 0 | %i |
| signed интегральный тип | %d |
| unsigned интегральный тип | %u |
| Тип | Модификатор длины |
| short | h |
| unsigned short | h |
| long | l |
| unsigned long | l |
| long long | ll |
| unsigned long long | ll |
| double | l |
| long double | L |
| Состояние | stdio эквивалент |
| basefield == ios_base::oct | %o |
| (basefield == ios_base::hex) && !uppercase | %x |
| (basefield == ios_base::hex) | %X |
| для signed целого типа | %d |
| для unsigned целого типа | %u |
| Состояние | stdio эквивалент |
| floatfield == ios_base::fixed | %f |
| floatfield == ios_base::scientific && !uppercase | %e |
| floatfield == ios_base::scientific | %E |
| floatfield == (ios_base::fixed | ios_base::scientific) && !uppercase | %a |
| floatfield == (ios_base::fixed | ios_base::scientific) | %A |
| !uppercase | %g |
| otherwise | %G |
| Тип | Модификатор длины |
| long | l |
| long long | ll |
| unsigned long | l |
| unsigned long long | ll |
| long double | L |
| otherwise | none |
| Тип (ы) | Состояние | stdio эквивалент |
| интегральный тип | showpos | + |
| showbase | # | |
| тип с плавающей запятой | showpos | + |
| showpoint | # |
| Состояние | Место нахождения |
| adjustfield == ios_base::left | подушечка после |
| adjustfield == ios_base::right | колодка перед |
| adjustfield == internal и знак встречается в представлении | блокнот после знака |
| adjustfield == internal и представление после этапа 1 началось с 0x или 0X | проложить после x или X |
| otherwise | колодка перед |
| date_order() | Формат |
| no_order | "%m%d%y" |
| dmy | "%d%m%y" |
| mdy | "%m%d%y" |
| ymd | "%y%m%d" |
| ydm | "%y%d%m" |
| fprintf | isprint | iswdigit | localeconv | tolower |
| fscanf | ispunct | iswgraph | mblen | toupper |
| isalnum | isspace | iswlower | mbstowcs | towlower |
| isalpha | isupper | iswprint | mbtowc | towupper |
| isblank | iswalnum | iswpunct | setlocale | wcscoll |
| iscntrl | iswalpha | iswspace | strcoll | wcstod |
| isdigit | iswblank | iswupper | strerror | wcstombs |
| isgraph | iswcntrl | iswxdigit | strtod | wcsxfrm |
| islower | iswctype | isxdigit | strxfrm | wctomb |
| Подпункт | Заголовок (ы) | |
| [container.requirements] | Требования | |
| [sequences] | Контейнеры последовательности | <array> |
| <deque> | ||
| <forward_list> | ||
| <list> | ||
| <vector> | ||
| [associative] | Ассоциативные контейнеры | <map> |
| <set> | ||
| [unord] | Неупорядоченные ассоциативные контейнеры | <unordered_map> |
| <unordered_set> | ||
| [container.adaptors] | Адаптеры для контейнеров | <queue> |
| <stack> | ||
| Выражение | Тип возврата | Оперативный | Утверждение / примечание | Сложность |
| семантика | до / после состояния | |||
| X::value_type | T | Requires: T это Erasable от X (см [container.requirements.general], ниже) | время компиляции | |
| X::reference | T& | время компиляции | ||
| X::const_reference | const T& | время компиляции | ||
| X::iterator | тип итератора, тип значения которого T | любая категория итераторов, отвечающая требованиям прямого итератора. конвертируемый в X::const_iterator. | время компиляции | |
| X::const_iterator | постоянный тип итератора, тип значения которого T | любая категория итераторов, отвечающая требованиям прямого итератора. | время компиляции | |
| X::difference_type | знаковый целочисленный тип | идентичен типу разницы X::iterator и X::const_iterator | время компиляции | |
| X::size_type | беззнаковый целочисленный тип | size_type может представлять любое неотрицательное значение difference_type | время компиляции | |
| X u; | Postconditions: u.empty() | постоянный | ||
| X() | Postconditions: X().empty() | постоянный | ||
| X(a) |
Requires: T находится CopyInsertable
в X (см. ниже). Postconditions: a == X(a). | линейный | ||
| X u(a); X u = a; |
Requires: T находится CopyInsertable
в X (см. ниже). Postconditions: u == a | линейный | ||
| X u(rv); X u = rv; | Postconditions: u будет равняться значению, которое rv имело до этого строительства | (Примечание B) | ||
| a = rv | X& | Все существующие элементы a либо перемещаются, либо уничтожаются. | a должно быть равно значению, которое rv имело до этого присвоения | линейный |
| (&a)->~X() | void | деструктор применяется к каждому элементу a; любая полученная память освобождается. | линейный | |
| a.begin() | iterator; const_iterator для постоянного a | постоянный | ||
| a.end() | iterator; const_iterator для постоянного a | постоянный | ||
| a.cbegin() | const_iterator | const_cast<X const&>(a).begin(); | постоянный | |
| a.cend() | const_iterator | const_cast<X const&>(a).end(); | постоянный | |
| a == b | конвертируемый в bool | == является отношением эквивалентности. equal(a.begin(), a.end(), b.begin(), b.end()) | Requires: T является EqualityComparable | Постоянно, если a.size() != b.size(), линейно в противном случае |
| a != b | конвертируемый в bool | Эквивалентно !(a == b) | линейный | |
| a.swap(b) | void | обменивается содержимым a и b | (Примечание А) | |
| swap(a, b) | void | a.swap(b) | (Примечание А) | |
| r = a | X& | Postconditions: r == a. | линейный | |
| a.size() | size_type | distance(a.begin(), a.end()) | постоянный | |
| a.max_size() | size_type | distance(begin(), end()) для максимально возможного контейнера | постоянный | |
| a.empty() | конвертируемый в bool | a.begin() == a.end() | постоянный |
| Выражение | Тип возврата | Утверждение / примечание | Сложность |
| до / после состояния | |||
| X::reverse_iterator | тип итератора, тип значения которого T | reverse_iterator<iterator> | время компиляции |
| X::const_reverse_iterator | постоянный тип итератора, тип значения которого T | reverse_iterator<const_iterator> | время компиляции |
| a.rbegin() | reverse_iterator; const_reverse_iterator для постоянного a | reverse_iterator(end()) | постоянный |
| a.rend() | reverse_iterator; const_reverse_iterator для постоянного a | reverse_iterator(begin()) | постоянный |
| a.crbegin() | const_reverse_iterator | const_cast<X const&>(a).rbegin() | постоянный |
| a.crend() | const_reverse_iterator | const_cast<X const&>(a).rend() | постоянный |
| Выражение | Тип возврата | Оперативный | Утверждение / примечание | Сложность |
| семантика | до / после состояния | |||
| a < b | конвертируемый в bool | lexicographical_compare( a.begin(), a.end(), b.begin(), b.end()) | Requires: < определяется для значений T. < это отношения полного порядка. | линейный |
| a > b | конвертируемый в bool | b < a | линейный | |
| a <= b | конвертируемый в bool | !(a > b) | линейный | |
| a >= b | конвертируемый в bool | !(a < b) | линейный |
| Выражение | Тип возврата | Утверждение / примечание | Сложность |
| до / после состояния | |||
| allocator_type | A | Requires: allocator_type::value_type то же самое, что и X::value_type. | время компиляции |
| get_- allocator() | A | постоянный | |
| X() X u; |
Requires: A есть DefaultConstructible. Postconditions: u.empty() возвращается true, u.get_allocator() == A() | постоянный | |
| X(m) | Postconditions: u.empty() возвращается true, | постоянный | |
| X u(m); | u.get_allocator() == m | ||
| X(t, m) X u(t, m); |
Requires: T находится CopyInsertable в X. Postconditions: u == t, u.get_allocator() == m | линейный | |
| X(rv) X u(rv); | Postconditions: u должен иметь те же элементы, что rv и до этого строительства; значение u.get_allocator() должно быть таким же, как значение rv.get_allocator() до этого строительства. | постоянный | |
| X(rv, m) X u(rv, m); |
Requires: T находится
MoveInsertable в X. Postconditions: u должны иметь те же элементы или копии элементов, которые rv были до этого строительства, u.get_allocator() == m | постоянная, если m == rv.get_allocator(), в противном случае линейная | |
| a = t | X& |
Requires: T находится
CopyInsertable в X
и CopyAssignable. Postconditions: a == t | линейный |
| a = rv | X& |
Requires: Если есть , это
в и
. Все существующие элементы
либо передаются, либо уничтожаются. будет равно значению, которое имело до этого присвоения. allocator_- traits<allocator_type> ::propagate_on_container_- move_assignment::value false T MoveInsertable X MoveAssignable a Postconditions: a rv | линейный |
| a.swap(b) | void | обменивается содержимым a и b | постоянный |
| Выражение | Тип возврата | Утверждение / примечание |
| до / после состояния | ||
|
X(n, t) X u(n, t); |
Requires: T должен быть
CopyInsertable в X.
Создает контейнер последовательности с копиями Postconditions: distance(begin(), end()) == n n t | |
| X(i, j) X u(i, j); |
Requires: T должен быть EmplaceConstructible в X от *i. Ибо vector, если итератор не соответствует forward iterator requirements, T
также должен быть
MoveInsertable включен X. Каждый итератор в диапазоне [i, j) должен быть разыменован ровно один раз.
Создает контейнер последовательности, равный диапазону Postconditions: distance(begin(), end()) == distance(i, j) [i, j) | |
| X(il) | Эквивалентно X(il.begin(), il.end()) | |
| a = il | X& |
Requires: T находится
CopyInsertable в X
и CopyAssignable. Назначает диапазон [il.begin(), il.end()) в a. Все существующие элементы a либо присваиваются, либо уничтожаются. Returns: *this. |
| a.emplace(p, args) | iterator | Requires: T находится EmplaceConstructible в X от args. Для vector и deque, T также MoveInsertable в X и MoveAssignable. Effects: Вставляет объект типа, созданного T с помощью std::forward<Args>(args)... before p. |
| a.insert(p,t) | iterator |
Requires: T должен быть
CopyInsertable в X. Для vector и deque,
T также должно быть CopyAssignable. Effects: Вставляет копию t ранее p. |
| a.insert(p,rv) | iterator |
Requires: T должен быть
MoveInsertable в X. Для vector и deque,
T также должно быть MoveAssignable. Effects: Вставляет копию rv ранее p. |
| a.insert(p,n,t) | iterator |
Requires: T должны быть
CopyInsertable в X
и CopyAssignable. Вставляет n копии t ранее p. |
| a.insert(p,i,j) | iterator |
Requires: T должен быть EmplaceConstructible в X от *i. Для vector и deque, T должен также быть
MoveInsertable в X, MoveConstructible, MoveAssignable, и swappable. Каждый итератор в диапазоне [i, j) должен быть разыменован ровно один раз. Requires: i и j не являются итераторами a. Вставляет копии элементов [i, j) перед p |
| a.insert(p, il) | iterator | a.insert(p, il.begin(), il.end()). |
| a.erase(q) | iterator |
Requires: Для vector и deque,
T должно быть MoveAssignable. Effects: Удаляет элемент, на который указывает q. |
| a.erase(q1,q2) | iterator |
Requires: Для vector и deque,
T должно быть MoveAssignable. Effects: Стирает элементы в диапазоне [q1, q2). |
| a.clear() | void |
Уничтожает все элементы в a. Делает недействительными все ссылки, указатели и итераторы, относящиеся к элементам, a и может сделать недействительным итератор, прошедший за конец. Postconditions: a.empty() возвращается true. Complexity: Линейный. |
| a.assign(i,j) | void |
Requires: T должно быть EmplaceConstructible в X от *i
и может быть назначено от *i. Ибо vector, если итератор не соответствует forward iterator requirements, T
также должен быть
MoveInsertable включен X. Каждый итератор в диапазоне [i, j) должен быть разыменован ровно один раз. Requires: i, j не являются итераторами в a. Заменяет элементы в a копии [i, j). Делает недействительными все ссылки, указатели и итераторы, относящиеся к элементам a. Для vector и dequeтакже делает недействительным итератор, прошедший за конец. |
| a.assign(il) | void | a.assign(il.begin(), il.end()). |
| a.assign(n,t) | void |
Requires: T должны быть
CopyInsertable в X
и CopyAssignable. Requires: t это не ссылка на a. Заменяет элементы a с n копиями t. Делает недействительными все ссылки, указатели и итераторы, относящиеся к элементам a. Для vector и dequeтакже делает недействительным итератор, прошедший за конец. |
| Выражение | Тип возврата | Операционная семантика | Контейнер |
| a.front() | reference; const_reference для постоянного a | *a.begin() | basic_string, array, deque, forward_list, list, vector |
| a.back() | reference; const_reference для постоянного a |
{ auto tmp = a.end(); --tmp; return *tmp; } | basic_string, array, deque, list, vector |
| a.emplace_front(args) | reference |
Добавляет объект типа, созданный T с помощью std::forward<Args>(args).... Requires: T должен быть EmplaceConstructible в X от args. Returns: a.front(). | deque, forward_list, list |
| a.emplace_back(args) | reference |
Добавляет объект типа, созданного T с помощью std::forward<Args>(args).... Requires: T должен быть EmplaceConstructible в X от args. Для vector, T также должны быть MoveInsertable в X. Returns: a.back(). | deque, list, vector |
| a.push_front(t) | void |
Готовит копию t. Requires: T должен быть CopyInsertable в X. | deque, forward_list, list |
| a.push_front(rv) | void |
Готовит копию rv. Requires: T должен быть MoveInsertable в X. | deque, forward_list, list |
| a.push_back(t) | void |
Добавляет копию t. Requires: T должен быть CopyInsertable в X. | basic_string, deque, list, vector |
| a.push_back(rv) | void |
Добавляет копию rv. Requires: T должен быть MoveInsertable в X. | basic_string, deque, list, vector |
| a.pop_front() | void |
Уничтожает первый элемент. Requires: a.empty() будет false. | deque, forward_list, list |
| a.pop_back() | void |
Уничтожает последний элемент. Requires: a.empty() будет false. | basic_string, deque, list, vector |
| a[n] | reference; const_reference для постоянного a | *(a.begin() + n) | basic_string, array, deque, vector |
| a.at(n) | reference; const_reference для постоянного a | *(a.begin() + n) | basic_string, array, deque, vector |
| map<K, T, C1, A> | map<K, T, C2, A> |
| map<K, T, C1, A> | multimap<K, T, C2, A> |
| set<K, C1, A> | set<K, C2, A> |
| set<K, C1, A> | multiset<K, C2, A> |
| unordered_map<K, T, H1, E1, A> | unordered_map<K, T, H2, E2, A> |
| unordered_map<K, T, H1, E1, A> | unordered_multimap<K, T, H2, E2, A> |
| unordered_set<K, H1, E1, A> | unordered_set<K, H2, E2, A> |
| unordered_set<K, H1, E1, A> | unordered_multiset<K, H2, E2, A> |
| Выражение | Тип возврата | Утверждение / примечание | Сложность |
| до / после состояния | |||
| X::key_type | Key | время компиляции | |
| X::mapped_type ( map и multimap только) | T | время компиляции | |
| X::value_type ( set и multiset только) | Key | Requires: value_type это Erasable из X | время компиляции |
| X::value_type ( map и multimap только) | pair<const Key, T> | Requires: value_type это Erasable из X | время компиляции |
| X::key_compare | Compare | Requires: key_compare есть CopyConstructible. | время компиляции |
| X::value_compare | бинарный тип предиката | то же самое, что и key_compare для set и multiset; является отношением порядка на парах, индуцированным первой компонентой (т. е. Key) для map и multimap. | время компиляции |
| X::node_type | специализация node_handle шаблона класса, так что общедоступные вложенные типы являются теми же типами, что и соответствующие типы в X. | видеть [container.node] | время компиляции |
| X(c) X u(c); | Effects: Создает пустой контейнер. Использует копию c как объект сравнения. | постоянный | |
| X() X u; |
Requires: key_compare есть DefaultConstructible. Effects: Создает пустой контейнер. Используется Compare() как объект сравнения | постоянный | |
| X(i,j,c) X u(i,j,c); |
Requires: value_type находится EmplaceConstructible в X от *i. Effects: Создает пустой контейнер и вставляет в него элементы из диапазона [i, j) ; используется c как объект сравнения. | NlogN в общем, где N имеет значение distance(i, j); линейный, если [i, j) отсортировано с помощью value_comp() | |
| X(i,j) X u(i,j); |
Requires: key_compare есть DefaultConstructible.
value_type находится EmplaceConstructible в X от *i. Effects: То же, что и выше, но используется Compare() как объект сравнения. | то же, что и выше | |
| X(il) | такой же как X(il.begin(), il.end()) | такой же как X(il.begin(), il.end()) | |
| X(il,c) | такой же как X(il.begin(), il.end(), c) | такой же как X(il.begin(), il.end(), c) | |
| a = il | X& |
Requires: value_type находится
CopyInsertable в X
и CopyAssignable. Effects: Назначает диапазон [il.begin(), il.end()) в a. Все существующие элементы a либо присваиваются, либо уничтожаются. | NlogN в общем, где N имеет значение il.size() + a.size(); линейный, если [il.begin(), il.end()) отсортировано с помощью value_comp() |
| b.key_comp() | X::key_compare | возвращает объект сравнения, из которого b был построен. | постоянный |
| b.value_comp() | X::value_compare | возвращает объект, value_compare созданный из объекта сравнения | постоянный |
| a_uniq.emplace(args) | pair<iterator, bool> |
Requires: value_type должен быть EmplaceConstructible в X от args. Effects: Вставляет value_type объект, t созданный с помощью std::forward<Args>(args)... if и только если в контейнере нет элемента с ключом, эквивалентным ключу t. bool Компонент возвращаемой пары true тогда и только тогда , когда имеет место вставка, а итератор компонент из точек пары к элементу с ключом , эквивалентным ключом t. | логарифмический |
| a_eq.emplace(args) | iterator |
Requires: value_type должен быть EmplaceConstructible в X от args. Effects: Вставляет value_type объект, созданный t с помощью, std::forward<Args>(args)... и возвращает итератор, указывающий на вновь вставленный элемент. Если диапазон, содержащий элементы, эквивалентные t существующим в a_eq, t вставляется в конец этого диапазона. | логарифмический |
| a.emplace_hint(p, args) | iterator | эквивалентно a.emplace( std::forward<Args>(args)...). Возвращаемое значение - это итератор, указывающий на элемент с ключом, эквивалентным вновь вставленному элементу. Элемент вставляется как можно ближе к позиции непосредственно перед p. | логарифмическая в целом, но амортизированная константа, если элемент вставлен прямо перед p |
| a_uniq.insert(t) | pair<iterator, bool> |
Requires: Если t - неконстантное выражение rvalue, value_type должно быть
MoveInsertable в X; в противном случае value_type будет
CopyInsertable в X. Effects: Вставляет t тогда и только тогда, когда в контейнере нет элемента с ключом, эквивалентным ключу t. bool Компонент возвращаемой пары true тогда и только тогда , когда имеет место вставки, и iterator компонент точек пары к элементу с ключом , эквивалентным ключом t. | логарифмический |
| a_eq.insert(t) | iterator |
Requires: Если t - неконстантное выражение rvalue, value_type должно быть
MoveInsertable в X; в противном случае value_type будет
CopyInsertable в X. Effects: Вставляет t и возвращает итератор, указывающий на вновь вставленный элемент. Если диапазон, содержащий элементы, эквивалентные t существующим в a_eq, t вставляется в конец этого диапазона. | логарифмический |
| a.insert(p, t) | iterator |
Requires: Если t - неконстантное выражение rvalue, value_type должно быть
MoveInsertable в X; в противном случае value_type будет
CopyInsertable в X. Effects: Вставляет, t если и только если нет элемента с ключом, эквивалентным ключу t в контейнерах с уникальными ключами; всегда вставляет t в контейнеры с эквивалентными ключами. Всегда возвращает итератор, указывающий на элемент с ключом, эквивалентным ключу t. t вставляется как можно ближе к позиции непосредственно перед p. | логарифмическая в целом, но амортизированная константа, если t вставлена прямо перед ней p. |
| a.insert(i, j) | void |
Requires: value_type должен быть EmplaceConstructible в X от *i. Requires: i, j не являются итераторами в a. вставляет каждый элемент из диапазона [i, j) тогда и только тогда, когда нет элемента с ключом, эквивалентным ключу этого элемента, в контейнерах с уникальными ключами; всегда вставляет этот элемент в контейнеры с эквивалентными ключами. | Nlog(a.size()+N), где N имеет значение distance(i, j) |
| a.insert(il) | void | эквивалентно a.insert(il.begin(), il.end()) | |
| a_uniq.insert(nh) | insert_return_type |
Requires: nh пусто или
a_uniq.get_allocator() == nh.get_allocator(). Effects: Если nh пусто, не действует. В противном случае вставляет элемент, владельцем которого является, nh тогда и только тогда, когда в контейнере нет элемента с ключом, эквивалентным nh.key(). Postconditions: Если nh пусто, inserted есть false, position есть end()и node пусто. В противном случае, если вставка имела место, inserted is true, position указывает на вставленный элемент и node является пустым; если вставка не удалась, inserted это false, node имеет предыдущее значение nh, и position указывает на элемент с ключом , эквивалентным nh.key(). | логарифмический |
| a_eq.insert(nh) | iterator |
Requires: nh пусто или
a_eq.get_allocator() == nh.get_allocator(). Effects: Если nh пусто, не действует и возвращается a_eq.end(). В противном случае вставляет элемент, которым владеет, nh и возвращает итератор, указывающий на вновь вставленный элемент. Если диапазон, содержащий элементы с ключами, эквивалентными, nh.key() существует в a_eq, элемент вставляется в конец этого диапазона. Postconditions: nh пустой. | логарифмический |
| a.insert(p, nh) | iterator |
Requires: nh пусто или
a.get_allocator() == nh.get_allocator(). Effects: Если nh пусто, не действует и возвращается a.end(). В противном случае вставляет элемент, принадлежащий пользователю nh тогда и только тогда, когда нет элемента с ключом, эквивалентным nh.key() в контейнерах с уникальными ключами; всегда вставляет элемент, которым владеет, nh в контейнеры с эквивалентными ключами. Всегда возвращает итератор, указывающий на элемент с ключом, эквивалентным nh.key(). Элемент вставляется как можно ближе к позиции непосредственно перед p. Postconditions: nh пусто, если вставка прошла успешно, не изменяется, если вставка не удалась. | логарифмическая в общем случае, но амортизированная константа, если элемент вставлен прямо перед ним p. |
| a.extract(k) | node_type | удаляет первый элемент в контейнере с ключом, эквивалентным k. Возвращает элемент, node_type владеющий элементом, если он найден, в противном случае - пустой node_type. | log(a.size()) |
| a.extract(q) | node_type | удаляет элемент, на который указывает q. Возвращает node_type владение этим элементом. | амортизированная постоянная |
| a.merge(a2) | void |
Requires: a.get_allocator() == a2.get_allocator(). Пытается извлечь каждый элемент a2 и вставить его с a помощью объекта сравнения a. В контейнерах с уникальными ключами, если есть элемент a с ключом, эквивалентным ключу элемента из a2, то этот элемент не извлекается из a2. Postconditions: Указатели и ссылки на переданные элементы a2 относятся к тем же элементам, но как членам a. Итераторы, относящиеся к переданным элементам, будут продолжать ссылаться на свои элементы, но теперь они ведут себя как итераторы в a, а не в a2. Throws: Ничего, если объект сравнения не выбрасывает. | Nlog(a.size()+N), где N имеет значение a2.size(). |
| a.erase(k) | size_type | стирает все элементы в контейнере с ключом, эквивалентным k. возвращает количество стертых элементов. | log(a.size())+a.count(k) |
| a.erase(q) | iterator | стирает элемент, на который указывает q. Возвращает итератор, указывающий на элемент, следующий сразу за q стираемым элементом. Если такого элемента нет, возвращается a.end(). | амортизированная постоянная |
| a.erase(r) | iterator | стирает элемент, на который указывает r. Возвращает итератор, указывающий на элемент, следующий сразу за r стираемым элементом. Если такого элемента нет, возвращается a.end(). | амортизированная постоянная |
| a.erase( q1, q2) | iterator | стирает все элементы в диапазоне [q1, q2). Возвращает итератор, указывающий на элемент, на который указывает до q2 стирания каких-либо элементов. Если такого элемента не существует, a.end() возвращается. | log(a.size())+N, где N имеет значение distance(q1, q2). |
| a.clear() | void |
a.erase(a.begin(),a.end()) Postconditions: a.empty() возвращается true. | линейно в a.size(). |
| b.find(k) | iterator; const_iterator для постоянного b. | возвращает итератор, указывающий на элемент с ключом, эквивалентным k, или b.end() если такой элемент не найден | логарифмический |
| a_tran. find(ke) | iterator; const_iterator для постоянного a_tran. | возвращает итератор, указывающий на элемент с r таким ключом , что !c(r, ke) && !c(ke, r), или a_tran.end() если такой элемент не найден | логарифмический |
| b.count(k) | size_type | возвращает количество элементов с ключом, эквивалентным k | log(b.size())+b.count(k) |
| a_tran. count(ke) | size_type | возвращает количество элементов с r таким ключом , что !c(r, ke) && !c(ke, r) | log(a_tran.size())+a_tran.count(ke) |
| b.lower_bound(k) | iterator; const_iterator для постоянного b. | возвращает итератор, указывающий на первый элемент с ключом не меньше чем k, или b.end() если такой элемент не найден. | логарифмический |
| a_tran. lower_bound(kl) | iterator; const_iterator для постоянного a_tran. | возвращает итератор, указывающий на первый элемент с r таким ключом , что !c(r, kl)или, a_tran.end() если такой элемент не найден. | логарифмический |
| b.upper_bound(k) | iterator; const_iterator для постоянного b. | возвращает итератор, указывающий на первый элемент с ключом больше чем k, или b.end() если такой элемент не найден. | логарифмический |
| a_tran. upper_bound(ku) | iterator; const_iterator для постоянного a_tran. | возвращает итератор, указывающий на первый элемент с r таким ключом , что c(ku, r)или, a_tran.end() если такой элемент не найден. | логарифмический |
| b.equal_range(k) | pair<iterator, iterator>; pair<const_iterator, const_iterator> для постоянного b. | эквивалентно make_pair(b.lower_bound(k), b.upper_bound(k)). | логарифмический |
| a_tran. equal_range(ke) | pair<iterator, iterator>; pair<const_iterator, const_iterator> для постоянного a_tran. |
эквивалентно . make_pair( a_tran.lower_bound(ke), a_tran.upper_bound(ke)) | логарифмический |
| Выражение | Тип возврата | Утверждение / примечание | Сложность |
| до / после состояния | |||
| X::key_type | Key | время компиляции | |
| X::mapped_type ( unordered_map и unordered_multimap только) | T | время компиляции | |
| X::value_type ( unordered_set и unordered_multiset только) | Key | Requires: value_type это Erasable из X | время компиляции |
| X::value_type ( unordered_map и unordered_multimap только) | pair<const Key, T> | Requires: value_type это Erasable из X | время компиляции |
| X::hasher | Hash | Hash должен быть унарным типом функционального объекта, так что выражение hf(k) имеет тип size_t. | время компиляции |
| X::key_equal | Pred | Requires: Pred есть CopyConstructible. Pred должен быть двоичным предикатом, который принимает два аргумента типа Key. Pred является отношением эквивалентности. | время компиляции |
| X::local_iterator | Тип итератора, категория, тип значения, тип различия, указатель и ссылочный тип которого совпадают с типом итератора X::iterator. | local_iterator Объект может быть использован для итерации через одно ведро, но не может быть использован для итерации по ковшам. | время компиляции |
| X::const_local_iterator | Тип итератора, категория, тип значения, тип различия, указатель и ссылочный тип которого совпадают с типом итератора X::const_iterator. | const_local_iterator Объект может быть использован для итерации через одно ведро, но не может быть использован для итерации по ковшам. | время компиляции |
| X::node_type | специализация node_handle шаблона класса, так что общедоступные вложенные типы являются теми же типами, что и соответствующие типы в X. | видеть [container.node] | время компиляции |
|
X(n, hf, eq) X a(n, hf, eq); | X | Effects: Создает пустой контейнер, по крайней мере n , с ведрами, используя hf в качестве хеш-функции и eq в качестве ключевого предиката равенства. | O(n) |
|
X(n, hf) X a(n, hf); | X | Requires: key_equal есть DefaultConstructible. Effects: Создает пустой контейнер, по крайней мере n , с ведрами, используя hf в качестве хеш-функции и key_equal() в качестве ключевого предиката равенства. | O(n) |
|
X(n) X a(n); | X | Requires: hasher и key_equal есть DefaultConstructible. Effects: Создает пустой контейнер, по крайней мере n , с ведрами, используя hasher() в качестве хеш-функции и key_equal() в качестве ключевого предиката равенства. | O(n) |
|
X() X a; | X | Requires: hasher и key_equal есть DefaultConstructible. Effects: Создает пустой контейнер с неопределенным количеством сегментов, используя hasher() в качестве хеш-функции и key_equal() в качестве ключевого предиката равенства. | постоянный |
|
X(i, j, n, hf, eq) X a(i, j, n, hf, eq); | X | Requires: value_type находится EmplaceConstructible в X от *i. Effects: Создает пустой контейнер как минимум с n корзинами, используя hf в качестве хеш-функции и eq в качестве ключевого предиката равенства, и вставляет [i, j) в него элементы из . | Средний случай O(N) ( N это distance(i, j)), в худшем случае O(N2) |
|
X(i, j, n, hf) X a(i, j, n, hf); | X | Requires: key_equal есть DefaultConstructible.
value_type находится EmplaceConstructible в X от *i. Effects: Создает пустой контейнер как минимум с n корзинами, используя hf в качестве хеш-функции и key_equal() в качестве ключевого предиката равенства, и вставляет [i, j) в него элементы из . | Средний случай O(N) ( N это distance(i, j)), в худшем случае O(N2) |
|
X(i, j, n) X a(i, j, n); | X | Requires: hasher и key_equal есть DefaultConstructible.
value_type находится EmplaceConstructible в X от *i. Effects: Создает пустой контейнер как минимум с n корзинами, используя hasher() в качестве хеш-функции и key_equal() в качестве ключевого предиката равенства, и вставляет [i, j) в него элементы из . | Средний случай O(N) ( N это distance(i, j)), в худшем случае O(N2) |
|
X(i, j) X a(i, j); | X | Requires: hasher и key_equal есть DefaultConstructible.
value_type находится EmplaceConstructible в X от *i. Effects: Создает пустой контейнер с неопределенным количеством сегментов, используя hasher() в качестве хэш-функции и key_equal() в качестве ключевого предиката равенства, и вставляет [i, j) в него элементы из . | Средний случай O(N) ( N это distance(i, j)), в худшем случае O(N2) |
| X(il) | X | То же, что и X(il.begin(), il.end()). | То же, что и X(il.begin(), il.end()). |
| X(il, n) | X | То же, что и X(il.begin(), il.end(), n). | То же, что и X(il.begin(), il.end(), n). |
| X(il, n, hf) | X | То же, что и X(il.begin(), il.end(), n, hf). | То же, что и X(il.begin(), il.end(), n, hf). |
| X(il, n, hf, eq) | X | То же, что и X(il.begin(), il.end(), n, hf, eq). | То же, что и X(il.begin(), il.end(), n, hf, eq). |
|
X(b) X a(b); | X | Конструктор копирования. В дополнение к требованиям Table 83, копирует хэш-функцию, предикат и максимальный коэффициент загрузки. | Средний случай линейный по b.size(), худший квадратичный. |
| a = b | X& | Оператор присваивания копий. В дополнение к требованиям Table 83, копирует хэш-функцию, предикат и максимальный коэффициент загрузки. | Средний случай линейный по b.size(), худший квадратичный. |
| a = il | X& | Requires: value_type находится
CopyInsertable в X
и CopyAssignable. Effects: Назначает диапазон [il.begin(), il.end()) в a. Все существующие элементы a либо присваиваются, либо уничтожаются. | То же, что и a = X(il). |
| b.hash_function() | hasher | Возвращает bхеш-функцию. | постоянный |
| b.key_eq() | key_equal | Возвращает bпредикат равенства ключей. | постоянный |
| a_uniq. emplace(args) | pair<iterator, bool> |
Requires: value_type должен быть EmplaceConstructible в X от args. Effects: Вставляет value_type объект, t созданный с помощью std::forward<Args>(args)... if и только если в контейнере нет элемента с ключом, эквивалентным ключу t. bool Компонент возвращаемой пары true тогда и только тогда , когда имеет место вставка, а итератор компонент из точек пары к элементу с ключом , эквивалентным ключом t. | Средний случай O(1), худший случай O(a_uniq.size()). |
| a_eq.emplace(args) | iterator |
Requires: value_type должен быть EmplaceConstructible в X от args. Effects: Вставляет value_type объект, созданный t с помощью, std::forward<Args>(args)... и возвращает итератор, указывающий на вновь вставленный элемент. | Средний случай O(1), худший случай O(a_eq.size()). |
| a.emplace_hint(p, args) | iterator |
Requires: value_type должен быть EmplaceConstructible в X от args. Effects: Эквивалентно a.emplace( std::forward<Args>(args)...). Возвращаемое значение - это итератор, указывающий на элемент с ключом, эквивалентным вновь вставленному элементу. Это const_iterator p подсказка, указывающая, где должен начинаться поиск. Реализациям разрешено игнорировать подсказку. | Средний случай O(1), худший случай O(a.size()). |
| a_uniq.insert(t) | pair<iterator, bool> | Requires: Если t - неконстантное выражение rvalue, value_type должно быть
MoveInsertable в X; в противном случае value_type будет
CopyInsertable в X. Effects: Вставляет t тогда и только тогда, когда в контейнере нет элемента с ключом, эквивалентным ключу t. bool Компонент возвращаемой пары указывает , имеет ли место вставки, и iterator компонент указывает на элемент с ключом , эквивалентным ключом t. | Средний случай O(1), худший случай O(a_uniq.size()). |
| a_eq.insert(t) | iterator | Requires: Если t - неконстантное выражение rvalue, value_type должно быть
MoveInsertable в X; в противном случае value_type будет
CopyInsertable в X. Effects: Вставляет tи возвращает итератор, указывающий на вновь вставленный элемент. | Средний случай O(1), худший случай O(a_eq.size()). |
| a.insert(p, t) | iterator | Requires: Если t - неконстантное выражение rvalue, value_type должно быть
MoveInsertable в X; в противном случае value_type будет
CopyInsertable в X. Effects: Эквивалентно a.insert (t). Возвращаемое значение - итератор, указывающий на элемент с ключом, эквивалентным ключу t. Итератор p - это подсказка, указывающая, где должен начинаться поиск. Реализациям разрешено игнорировать подсказку. | Средний случай O(1), худший случай O(a.size()). |
| a.insert(i, j) | void | Requires: value_type должен быть EmplaceConstructible в X от *i. Requires: i и j не являются итераторами в a. Эквивалентно a.insert(t) для каждого элемента в [i,j). | Средний случай O(N), где N есть distance(i, j). Худший случай O(N(a.size()+1)). |
| a.insert(il) | void | То же, что и a.insert(il.begin(), il.end()). | То же, что и a.insert( il.begin(), il.end()). |
|
a_uniq. insert(nh) | insert_return_type |
Requires: nh пусто или
a_uniq.get_allocator() == nh.get_allocator(). Effects: Если nh пусто, не действует. В противном случае вставляет элемент, владельцем которого является, nh тогда и только тогда, когда в контейнере нет элемента с ключом, эквивалентным nh.key(). Postconditions: Если nh пусто, inserted есть false, position есть end()и node пусто. В противном случае, если вставка имела место, inserted is true, position указывает на вставленный элемент и node является пустым; если вставка не удалась, inserted это false, node имеет предыдущее значение nh, и position указывает на элемент с ключом , эквивалентным nh.key(). | Средний случай O(1), худший случай O(a_uniq.size()). |
|
a_eq. insert(nh) | iterator |
Requires: nh пусто или
a_eq.get_allocator() == nh.get_allocator(). Effects: Если nh пусто, не действует и возвращается a_eq.end(). В противном случае вставляет элемент, которым владеет, nh и возвращает итератор, указывающий на вновь вставленный элемент. Postconditions: nh пустой. | Средний случай O(1), худший случай O(a_eq.size()). |
| a.insert(q, nh) | iterator |
Requires: nh пусто или
a.get_allocator() == nh.get_allocator(). Effects: Если nh пусто, не действует и возвращается a.end(). В противном случае вставляет элемент, принадлежащий пользователю nh тогда и только тогда, когда нет элемента с ключом, эквивалентным nh.key() в контейнерах с уникальными ключами; всегда вставляет элемент, которым владеет, nh в контейнеры с эквивалентными ключами. Всегда возвращает итератор, указывающий на элемент с ключом, эквивалентным nh.key(). Итератор q - это подсказка, указывающая, где должен начинаться поиск. Реализациям разрешено игнорировать подсказку. Postconditions: nh пусто, если вставка прошла успешно, не изменяется, если вставка не удалась. | Средний случай O(1), худший случай O(a.size()). |
| a.extract(k) | node_type | Удаляет элемент в контейнере с ключом, эквивалентным k. Возвращает элемент, node_type владеющий элементом, если он найден, в противном случае - пустой node_type. | Средний случай O(1), худший случай O(a.size()). |
| a.extract(q) | node_type | Удаляет элемент, на который указывает q. Возвращает node_type владение этим элементом. | Средний случай O(1), худший случай O(a.size()). |
| a.merge(a2) | void |
Requires: a.get_allocator() == a2.get_allocator(). Пытается извлечь каждый элемент a2 и вставить его, a используя хеш-функцию и предикат равенства ключей a. В контейнерах с уникальными ключами, если есть элемент a с ключом, эквивалентным ключу элемента из a2, то этот элемент не извлекается из a2. Postconditions: Указатели и ссылки на переданные элементы a2 относятся к тем же элементам, но как членам a. Итераторы, относящиеся к переданным элементам, и все итераторы, на которые ссылаются, a будут признаны недействительными, но итераторы для оставшихся элементов a2 останутся действительными. Throws: Ничего, если не выбрасывает хэш-функция или предикат равенства ключей. | Средний случай O(N), где N есть a2.size(). Худший случай O(N*a.size()+N). |
| a.erase(k) | size_type | Удаляет все элементы с ключом, эквивалентным k. Возвращает количество стертых элементов. | Средний случай O(a.count(k)). Худший случай O(a.size()). |
| a.erase(q) | iterator | Удаляет элемент, на который указывает q. Возвращает итератор, следующий сразу q за стиранием. | Средний случай O(1), худший случай O(a.size()). |
| a.erase(r) | iterator | Удаляет элемент, на который указывает r. Возвращает итератор, следующий сразу r за стиранием. | Средний случай O(1), худший случай O(a.size()). |
| a.erase(q1, q2) | iterator | Удаляет все элементы в диапазоне [q1, q2). Возвращает итератор сразу после стертых элементов до стирания. | Средний случай, линейный по distance(q1, q2), худший случай O(a.size()). |
| a.clear() | void | Удаляет все элементы в контейнере. Postconditions: a.empty() возвращается true | Линейный вход a.size(). |
| b.find(k) | iterator; const_iterator для конст b. | Возвращает итератор, указывающий на элемент с ключом, эквивалентным k, или b.end() если такой элемент не существует. | Средний случай O(1), худший случай O(b.size()). |
| b.count(k) | size_type | Возвращает количество элементов с ключом, эквивалентным k. | Средний случай O(b.count(k)), худший случай O(b.size()). |
| b.equal_range(k) | pair<iterator, iterator>; pair<const_iterator, const_iterator> для конст b. | Возвращает диапазон, содержащий все элементы с ключами, эквивалентными k. Возвращает, make_pair(b.end(), b.end()) если таких элементов не существует. | Средний случай O(b.count(k)). Худший случай O(b.size()). |
| b.bucket_count() | size_type | Возвращает количество содержащихся сегментов b . | Постоянный |
| b.max_bucket_count() | size_type | Возвращает верхнюю границу количества сегментов, которые b могут когда-либо содержаться. | Постоянный |
| b.bucket(k) | size_type |
Requires: b.bucket_count() > 0. Возвращает индекс корзины, в которой k были бы найдены элементы с ключами, эквивалентными , если бы такой элемент существовал. Postconditions: возвращаемое значение должно быть в диапазоне [0, b.bucket_count()). | Постоянный |
| b.bucket_size(n) | size_type | Requires: n должен быть в пределах [0, b.bucket_count()). Возвращает количество элементов в n th корзине. | O(b.bucket_size(n)) |
| b.begin(n) | local_iterator; const_local_iterator для конст b. | Requires: n должен быть в пределах [0, b.bucket_count()). b.begin(n) возвращает итератор, ссылающийся на первый элемент в корзине. Если ведро пустое, то b.begin(n) == b.end(n). | Постоянный |
| b.end(n) | local_iterator; const_local_iterator для конст b. | Requires: n должен быть в пределах [0, b.bucket_count()). b.end(n) возвращает итератор, который является последним значением для сегмента. | Постоянный |
| b.cbegin(n) | const_local_iterator | Requires: n должен быть в пределах [0, b.bucket_count()). Примечание. [b.cbegin(n), b.cend(n)) Это допустимый диапазон, содержащий все элементы в n th сегменте. | Постоянный |
| b.cend(n) | const_local_iterator | Requires: n должен быть в пределах [0, b.bucket_count()). | Постоянный |
| b.load_factor() | float | Возвращает среднее количество элементов в ведре. | Постоянный |
| b.max_load_factor() | float | Возвращает положительное число, при котором контейнер пытается сохранить коэффициент загрузки меньше или равным. Контейнер автоматически увеличивает количество ковшей по мере необходимости, чтобы коэффициент загрузки не превышал этого числа. | Постоянный |
| a.max_load_factor(z) | void | Requires: z должен быть положительным. Может изменить максимальный коэффициент загрузки контейнера, используя z как подсказку. | Постоянный |
| a.rehash(n) | void | Postconditions: a.bucket_count() >= a.size() / a.max_load_factor() и a.bucket_count() >= n. | Средний случай линейный по a.size(), худший квадратичный. |
| a.reserve(n) | void | То же, что и a.rehash(ceil(n / a.max_load_factor())). | Средний случай линейный по a.size(), худший квадратичный. |
| Подпункт | Заголовок (ы) | |
| [iterator.requirements] | Требования | |
| [iterator.primitives] | Итераторные примитивы | <iterator> |
| [predef.iterators] | Предопределенные итераторы | |
| [stream.iterators] | Итераторы потока | |
| Произвольный доступ | → Двунаправленный | → Вперед | → Вход |
| → Выход |
| Выражение | Тип возврата | Оперативный | Утверждение / примечание |
| семантика | до / после состояния | ||
| *r | неопределенные | Requires: r разыменуемо. | |
| ++r | X& |
| Выражение | Тип возврата | Оперативный | Утверждение / примечание |
| семантика | до / после состояния | ||
| a != b | контекстно конвертируемый в bool | !(a == b) | Requires: (a, b) находится в домене ==. |
| *a | reference, конвертируемый в T |
Requires: a разыменуемо. Выражение (void)*a, *a эквивалентно *a. Если a == b и (a, b) находится в домене, == то *a эквивалентно *b. | |
| a->m | (*a).m | Requires: a разыменуемо. | |
| ++r | X& |
Requires: r разыменуемо. Postconditions: r разыменован или окончен r ; любые копии предыдущего значения r больше не должны быть разыменованными или находиться в домене ==. | |
| (void)r++ | эквивалентно (void)++r | ||
| *r++ | конвертируемый в T |
{ T tmp = *r; ++r; return tmp; } |
| Выражение | Тип возврата | Оперативный | Утверждение / примечание |
| семантика | до / после состояния | ||
| *r = o | результат не используется |
Remarks: После этой операции r разыменование не требуется. Postconditions: r является увеличиваемым. | |
| ++r | X& |
&r == &++r. Remarks: После этой операции r разыменование не требуется. Postconditions: r является увеличиваемым. | |
| r++ | конвертируемый в const X& |
{ X tmp = r; ++r; return tmp; } |
Remarks: После этой операции r разыменование не требуется. Postconditions: r является увеличиваемым. |
| *r++ = o | результат не используется |
Remarks: После этой операции r разыменование не требуется. Postconditions: r является увеличиваемым. |
| Выражение | Тип возврата | Оперативный | Утверждение / примечание |
| семантика | до / после состояния | ||
| r++ | конвертируемый в const X& |
{ X tmp = r; ++r; return tmp; } | |
| *r++ | reference |
| Выражение | Тип возврата | Оперативный | Утверждение / примечание |
| семантика | до / после состояния | ||
| --r | X& |
Requires: существует s такое что r == ++s. Postconditions: r разыменуемо. --(++r) == r. --r == --s подразумевает r == s. &r == &--r. | |
| r-- | конвертируемый в const X& |
{ X tmp = r; --r; return tmp; } | |
| *r-- | reference |
| Выражение | Тип возврата | Оперативный | Утверждение / примечание |
| семантика | до / после состояния | ||
| r += n | X& |
{ difference_type m = n; if (m >= 0) while (m--) ++r; else while (m++) --r; return r; } | |
| a + n n + a | X |
{ X tmp = a; return tmp += n; } | a + n == n + a. |
| r -= n | X& | return r += -n; | Requires: абсолютное значение n находится в диапазоне представимых значений difference_type. |
| a - n | X |
{ X tmp = a; return tmp -= n; } | |
| b - a | difference_type | return n |
Requires: существует такое значение n типа difference_type , что a + n == b. b == a + (b - a). |
| a[n] | конвертируемый в reference | *(a + n) | |
| a < b | контекстно конвертируемый в bool | b - a > 0 | < отношение полного порядка |
| a > b | контекстно конвертируемый в bool | b < a | > отношение полного порядка, противоположное <. |
| a >= b | контекстно конвертируемый в bool | !(a < b) | |
| a <= b | контекстно конвертируемый в bool. | !(a > b) |
| Подпункт | Заголовок (ы) | |
| [alg.nonmodifying] | Немодифицирующие операции последовательности | |
| [alg.modifying.operations] | Операции мутирующей последовательности | <algorithm> |
| [alg.sorting] | Сортировка и сопутствующие операции | |
| [alg.c.library] | Алгоритмы библиотеки C | <cstdlib> |
| Подпункт | Заголовок (ы) | |
| [numerics.defns] | Определения | |
| [numeric.requirements] | Требования | |
| [cfenv] | Среда с плавающей точкой | <cfenv> |
| [complex.numbers] | Сложные числа | <complex> |
| [rand] | Генерация случайных чисел | <random> |
| [numarray] | Числовые массивы | <valarray> |
| [numeric.ops] | Обобщенные числовые операции | <numeric> |
| [c.math] | Математические функции для | <cmath> |
| типы с плавающей запятой | <cstdlib> | |
| Выражение | Тип возврата | До / после состояния | Сложность |
| S::result_type | T | T представляет собой , unsigned integer type по меньшей мере , 32 бита. | время компиляции |
| S() | Создает начальную последовательность с тем же начальным состоянием, что и все другие исходные последовательности типа, сконструированные по умолчанию S. | постоянный | |
| S(ib,ie) | Создает начальную последовательность, имеющую внутреннее состояние, которое зависит от некоторых или всех битов предоставленной последовательности [ib,ie). | O(ie−ib) | |
| S(il) | То же, что и S(il.begin(), il.end()). | такой же как S(il.begin(), il.end()) | |
| q.generate(rb,re) | void | Ничего не делает, если rb == re. В противном случае заполняет предоставленную последовательность [rb,re) 32-битными величинами, которые зависят от последовательности, предоставленной конструктору, и, возможно, также зависят от истории generateпредыдущих вызовов. | O(re−rb) |
| r.size() | size_t | Количество 32-битных единиц, которые будут скопированы при вызове r.param. | постоянный |
| r.param(ob) | void | Копирует в указанное место назначения последовательность 32-битных единиц, которые могут быть предоставлены конструктору второго объекта типа S, и которые будут воспроизводить в этом втором объекте состояние, неотличимое от состояния первого объекта. | O(r.size()) |
| Выражение | Тип возврата | До / после состояния | Сложность |
| G::result_type | T | T это unsigned integer type. | время компиляции |
| g() | T | Возвращает значение в замкнутом интервале [G::min(), G::max()]. | амортизированная постоянная |
| G::min() | T | Обозначает наименьшее значение, которое потенциально может вернуть operator(). | время компиляции |
| G::max() | T | Обозначает наибольшее значение, которое потенциально может вернуть operator(). | время компиляции |
| Выражение | Тип возврата | До / после состояния | Сложность |
| E() | Создает механизм с тем же начальным состоянием, что и все другие механизмы типа, построенные по умолчанию E. | O(size of state) | |
| E(x) | Создает движок, который сравнивает равный x. | O(size of state) | |
| E(s) | Создает движок с начальным состоянием, определяемым s. | O(size of state) | |
| E(q)268 | Создает движок с начальным состоянием, которое зависит от последовательности, созданной одним вызовом q.generate. | q.generate такая же, как сложность вызываемой последовательности, длина которой равна размеру состояния | |
| e.seed() | void | Postconditions: e == E(). | такой же как E() |
| e.seed(s) | void | Postconditions: e == E(s). | такой же как E(s) |
| e.seed(q) | void | Postconditions: e == E(q). | такой же как E(q) |
| e() | T | Авансы eдержавотворческая ei к ei+1 =TA(ei) и возвращается GA(ei). | за таблицу 103 |
| e.discard(z) 269 | void | Авансы eдержавотворческих ei к ei+z любому способу эквивалентного z последовательным вызовов e(). | не хуже сложности z последовательных звонков e() |
| x == y | bool | Этот оператор является отношением эквивалентности. С Sx и Sy как бесконечные последовательности значений, которые будут сгенерированы повторными вызовами в будущем, x() и y(), соответственно, возвращает true if Sx=Sy; иначе возвращается false. | O(size of state) |
| x != y | bool | !(x == y). | O(size of state) |
| os << x | ссылка на тип os | Если os.fmtflags задано значение ios_base::dec|ios_base::left и символ заполнения установлен на пробел, os выполняется запись в текстовое представление xтекущего состояния. В выводе соседние числа разделяются одним или несколькими пробелами. И символ - заполнитель не изменяются. Postconditions: os.fmtflags | O(size of state) |
| is >> v | ссылка на тип is | Если is.fmtflags установлено в ios_base::dec, устанавливает vсостояние, определяемое чтением его текстового представления из is. Если обнаружен неверный ввод, гарантирует, что vсостояние не изменится в результате операции и вызовов is.setstate(ios::failbit) (которые могут вызывать throw ios::failure ( [iostate.flags])). Если текстовое представление, записанное через, os << x было впоследствии прочитано через is >> v, то x == v при условии, что не было промежуточных вызовов of x или of v. Requires: is предоставляет текстовое представление, которое ранее было написано с использованием выходного потока, встроенная локаль которого была такой же, как и у is, и аргументы специализации шаблона charT и для которого traits были, соответственно, такими же, как у is. Неизменны. Postconditions: is.fmtflags | O(size of state) |
| Выражение | Тип возврата | До / после состояния | Сложность |
| D::result_type | T | T это arithmetic type. | время компиляции |
| D::param_type | P | время компиляции | |
| D() | Создает распределение, поведение которого неотличимо от поведения любого другого вновь созданного по умолчанию распределения типа D. | постоянный | |
| D(p) | Создает распределение, поведение которого неотличимо от поведения вновь созданного распределения, непосредственно из значений, используемых для построения p. | такая же, как pи конструкция | |
| d.reset() | void | Последующее использование d не зависит от значений, созданных каким-либо механизмом перед вызовом reset. | постоянный |
| x.param() | P | Возвращает такое значение p , что D(p).param() == p. | не хуже, чем сложность D(p) |
| d.param(p) | void | Postconditions: d.param() == p. | не хуже, чем сложность D(p) |
| d(g) | T | С p=d.param(), последовательность чисел, возвращаемая последовательными вызовами одного и того же объекта g , случайным образом распределяется в соответствии с ассоциированной функцией p(z |{p}) или P(zi|{p}). | амортизируемое постоянное количество вызовов g |
| d(g,p) | T | Последовательность чисел, возвращаемая последовательными вызовами одних g и тех же объектов, p случайным образом распределяется в соответствии с ассоциированной функцией p(z |{p}) или P(zi|{p})функцией. | амортизируемое постоянное количество вызовов g |
| x.min() | T | Возврат glb. | постоянный |
| x.max() | T | Возврат lub. | постоянный |
| x == y | bool | Этот оператор является отношением эквивалентности. Возвращает true if x.param() == y.param() и S1=S2, где S1 и S2 - бесконечные последовательности значений, которые будут генерироваться, соответственно, повторными вызовами в будущем x(g1) и y(g2) всякий раз g1 == g2. В противном случае возвращается false. | постоянный |
| x != y | bool | !(x == y). | так же, как x == y. |
| os << x | ссылка на тип os | Записывает в os текстовое представление параметры и дополнительные внутренние данные x. И символ - заполнитель не изменяются. Postconditions: os.fmtflags | |
| is >> d | ссылка на тип is | Восстанавливается из is параметров и дополнительных внутренних данных lvalue d. Если обнаружен неправильный ввод, гарантирует, что d операция и вызовы не изменят его is.setstate(ios::failbit) (что может вызвать throw ios::failure ( [iostate.flags])). Requires: is обеспечивает текстовое представление , которое было ранее написанным используя os которого пронизана локаль и чьи аргументы шаблона специализации типа в charT и traits были такими же , как те is. Неизменны. Postconditions: is.fmtflags |
| Подпункт | Заголовок (ы) | |
| [iostreams.requirements] | Требования | |
| [iostream.forward] | Форвардные декларации | <iosfwd> |
| [iostream.objects] | Стандартные объекты iostream | <iostream> |
| [iostreams.base] | Базовые классы Iostreams | <ios> |
| [stream.buffers] | Буферы потока | <streambuf> |
| [iostream.format] | Форматирование и манипуляторы | <istream> |
| <ostream> | ||
| <iomanip> | ||
| [string.streams] | Строковые потоки | <sstream> |
| [file.streams] | Файловые потоки | <fstream> |
| [filesystems] | Файловые системы | <filesystem> |
| [c.files] | Файлы библиотеки C | <cstdio> |
| <cinttypes> | ||
| Элемент | Эффект (ы), если установлен |
| boolalpha | вставить и извлечь bool тип в алфавитном формате |
| dec | преобразует целочисленный ввод или генерирует целочисленный вывод в десятичной системе счисления |
| fixed | генерировать вывод с плавающей запятой в нотации с фиксированной запятой |
| hex | преобразует целочисленный ввод или генерирует целочисленный вывод в шестнадцатеричной системе счисления |
| internal | добавляет символы заливки в обозначенную внутреннюю точку в определенном сгенерированном выводе или идентично, right если такая точка не обозначена |
| left | добавляет символы заливки справа (конечные позиции) определенного сгенерированного вывода |
| oct | преобразует целочисленный ввод или генерирует целочисленный вывод в восьмеричной системе счисления |
| right | добавляет символы заполнения слева (начальные позиции) определенного сгенерированного вывода |
| scientific | генерирует вывод с плавающей запятой в экспоненциальной нотации |
| showbase | генерирует префикс, указывающий числовую основу сгенерированного целочисленного вывода |
| showpoint | безоговорочно генерирует символ десятичной точки в сгенерированном выводе с плавающей запятой |
| showpos | генерирует + знак в неотрицательном сгенерированном числовом выводе |
| skipws | пропускает начальные пробелы перед определенными операциями ввода |
| unitbuf | сбрасывает вывод после каждой операции вывода |
| uppercase | заменяет определенные строчные буквы их эквивалентами в верхнем регистре в сгенерированном выводе |
| Постоянный | Допустимые значения |
| adjustfield | left | right | internal |
| basefield | dec | oct | hex |
| floatfield | scientific | fixed |
| Элемент | Эффект (ы), если установлен |
| badbit | указывает на потерю целостности во входной или выходной последовательности (например, на неисправимую ошибку чтения из файла); |
| eofbit | указывает, что операция ввода достигла конца входной последовательности; |
| failbit | указывает, что операция ввода не смогла прочитать ожидаемые символы или что операция вывода не смогла сгенерировать желаемые символы. |
| Элемент | Эффект (ы), если установлен |
| app | стремиться закончить перед каждой записью |
| ate | открывать и стремиться к завершению сразу после открытия |
| binary | выполнять ввод и вывод в двоичном режиме (в отличие от текстового режима) |
| in | открыт для ввода |
| out | открыт для вывода |
| trunc | обрезать существующий поток при открытии |
| Элемент | Имея в виду |
| beg | запросить поиск (для последующего ввода или вывода) относительно начала потока |
| cur | запросить поиск относительно текущей позиции в последовательности |
| end | запросить поиск относительно текущего конца последовательности |
| Выражение | Тип возврата | Оперативный | Утверждение / примечание |
| семантика | до / после состояния | ||
| P(i) |
p == P(i) примечание: предполагается деструктор. | ||
|
P p(i); P p = i; | Postconditions: p == P(i). | ||
| P(o) | fpos | конвертирует из offset | |
| O(p) | streamoff | конвертируется в offset | P(O(p)) == p |
| p == q | конвертируемый в bool | == является отношением эквивалентности | |
| p != q | конвертируемый в bool | !(p == q) | |
|
q = p + o p += o | fpos | + компенсировать | q - o == p |
|
q = p - o p -= o | fpos | - компенсировать | q + o == p |
| o = p - q | streamoff | расстояние | q + o == p |
|
streamsize(o) O(sz) |
streamsize streamoff |
обращает новообращенных |
streamsize(O(sz)) == sz streamsize(O(sz)) == sz |
| Элемент | Ценить |
| rdbuf() | sb |
| tie() | 0 |
| rdstate() | goodbit если sb не является нулевым указателем, в противном случае badbit. |
| exceptions() | goodbit |
| flags() | skipws | dec |
| width() | 0 |
| precision() | 6 |
| fill() | widen(' ') |
| getloc() | копия значения, возвращаемого locale() |
| iarray | нулевой указатель |
| parray | нулевой указатель |
| Элемент | Ценить |
| rdbuf() | unchanged |
| tie() | rhs.tie() |
| rdstate() | unchanged |
| exceptions() | rhs.exceptions() |
| flags() | rhs.flags() |
| width() | rhs.width() |
| precision() | rhs.precision() |
| fill() | rhs.fill() |
| getloc() | rhs.getloc() |
| Условия | Результат |
| (which & ios_base::in) == ios_base::in | позиционирует входную последовательность |
| (which & ios_base::out) == ios_base::out | позиционирует выходную последовательность |
|
(which & (ios_base::in | ios_base::out)) == (ios_base::in) | ios_base::out)) и way == либо, ios_base::beg либо ios_base::end | позиционирует как входную, так и выходную последовательности |
| Иначе | операция позиционирования не выполняется. |
| Состояние | newoff Ценить |
| way == ios_base::beg | 0 |
| way == ios_base::cur | следующий указатель минус указатель начала ( xnext - xbeg). |
| way == ios_base::end | указатель верхней отметки минус указатель начала ( high_mark - xbeg). |
| ios_base комбинация флагов | stdio эквивалент | ||||
| binary | in | out | trunc | app | |
| + | "w" | ||||
| + | + | "a" | |||
| + | "a" | ||||
| + | + | "w" | |||
| + | "r" | ||||
| + | + | "r+" | |||
| + | + | + | "w+" | ||
| + | + | + | "a+" | ||
| + | + | "a+" | |||
| + | + | "wb" | |||
| + | + | + | "ab" | ||
| + | + | "ab" | |||
| + | + | + | "wb" | ||
| + | + | "rb" | |||
| + | + | + | "r+b" | ||
| + | + | + | + | "w+b" | |
| + | + | + | + | "a+b" | |
| + | + | + | "a+b" | ||
| way Ценить | stdio Эквивалент |
| basic_ios::beg | SEEK_SET |
| basic_ios::cur | SEEK_CUR |
| basic_ios::end | SEEK_END |
| Выражение | Ценить |
| runtime_error::what() | what_arg.c_str() |
| code() | ec |
| path1().empty() | true |
| path2().empty() | true |
| Выражение | Ценить |
| runtime_error::what() | what_arg.c_str() |
| code() | ec |
| path1() | Ссылка на сохраненную копию p1 |
| path2().empty() | true |
| Выражение | Ценить |
| runtime_error::what() | what_arg.c_str() |
| code() | ec |
| path1() | Ссылка на сохраненную копию p1 |
| path2() | Ссылка на сохраненную копию p2 |
| Группа опций, управляющая copy_file эффектами функций для существующих целевых файлов | |
| Постоянный | Имея в виду |
| none | (По умолчанию) Ошибка; Файл уже существует. |
| skip_existing | Не перезаписывать существующий файл, не сообщать об ошибке. |
| overwrite_existing | Перезаписать существующий файл. |
| update_existing | Замените существующий файл, если он старше заменяемого. |
| Группа опций, управляющая copy эффектами функций для подкаталогов | |
| Постоянный | Имея в виду |
| none | (По умолчанию) Не копировать подкаталоги. |
| recursive | Рекурсивно копируйте подкаталоги и их содержимое. |
| Группа опций, управляющая copy эффектами функций для символьных ссылок | |
| Постоянный | Имея в виду |
| none | (По умолчанию) Переход по символическим ссылкам. |
| copy_symlinks | Копируйте символические ссылки как символические ссылки, а не копируйте файлы, на которые они указывают. |
| skip_symlinks | Игнорируйте символические ссылки. |
| Группа опций, управляющая copy эффектами функций для выбора формы копирования | |
| Постоянный | Имея в виду |
| none | (По умолчанию) Копировать содержимое. |
| directories_only | Копировать только структуру каталогов, не копировать файлы, не являющиеся каталогами. |
| create_symlinks | Делайте символические ссылки вместо копий файлов. Исходный путь должен быть абсолютным, если путь назначения не находится в текущем каталоге. |
| create_hard_links | Делайте жесткие ссылки вместо копий файлов. |
| Имя | Ценить | POSIX | Определение или примечания |
| (восьмеричный) | макрос | ||
| none | 0 | Для файла не установлены разрешения. | |
| owner_read | 0400 | S_IRUSR | Разрешение на чтение, владелец |
| owner_write | 0200 | S_IWUSR | Разрешение на запись, владелец |
| owner_exec | 0100 | S_IXUSR | Разрешение на выполнение / поиск, владелец |
| owner_all | 0700 | S_IRWXU |
Читать, писать, выполнять / искать по владельцу; owner_read | owner_write | owner_exec |
| group_read | 040 | S_IRGRP | Разрешение на чтение, группа |
| group_write | 020 | S_IWGRP | Разрешение на запись, группа |
| group_exec | 010 | S_IXGRP | Разрешение на выполнение / поиск, группа |
| group_all | 070 | S_IRWXG |
Чтение, запись, выполнение / поиск по группе; group_read | group_write | group_exec |
| others_read | 04 | S_IROTH | Разрешение на чтение, другие |
| others_write | 02 | S_IWOTH | Разрешение на запись, другие |
| others_exec | 01 | S_IXOTH | Разрешение на выполнение / поиск, другие |
| others_all | 07 | S_IRWXO |
Читать, писать, выполнять / искать другие; others_read | others_write | others_exec |
| all | 0777 | owner_all | group_all | others_all | |
| set_uid | 04000 | S_ISUID | Установить идентификатор пользователя при выполнении |
| set_gid | 02000 | S_ISGID | Установить идентификатор группы при выполнении |
| sticky_bit | 01000 | S_ISVTX | Зависит от операционной системы. |
| mask | 07777 | all | set_uid | set_gid | sticky_bit | |
| unknown | 0xFFFF | Разрешения неизвестны, например, когда file_status объект создается без указания разрешений. |
| Имя | Имея в виду |
| replace | permissions должен заменить биты разрешений файла на perm |
| add | permissions должен заменить биты разрешения файла побитовым ИЛИ perm и текущими битами разрешения файла. |
| remove | permissions должен заменить биты разрешений файла побитовым И дополнением perm и текущими битами разрешений файла. |
| nofollow | permissions должен изменять разрешения самой символической ссылки, а не разрешения файла, к которому эта ссылка разрешает. |
| Имя | Имея в виду |
| none | (По умолчанию) Пропускать символические ссылки на каталог, отказано в разрешении - это ошибка. |
| follow_directory_symlink | Следуйте, а не пропускайте символические ссылки на каталоги. |
| skip_permission_denied | Пропускать каталоги, для которых в противном случае было бы отказано в разрешении. |
| Подпункт | Заголовок (ы) | |
| [re.def] | Определения | |
| [re.req] | Требования | |
| [re.const] | Константы | |
| [re.badexp] | Тип исключения | |
| [re.traits] | Черты | |
| [re.regex] | Шаблон регулярного выражения | <regex> |
| [re.submatch] | Подматчи | |
| [re.results] | Результаты матчей | |
| [re.alg] | Алгоритмы | |
| [re.iter] | Итераторы | |
| [re.grammar] | Грамматика | |
| Выражение | Тип возврата | Утверждение / примечание до / после условия |
| X::char_type | charT | Тип символьного контейнера, используемый в реализации шаблона класса basic_regex. |
| X::string_type | basic_string<charT> | |
| X::locale_type | Копируемый конструктивный тип | Тип, представляющий локаль, используемую классом свойств. |
| X::char_class_type | bitmask type. | Тип битовой маски, представляющий определенную классификацию символов. |
| X::length(p) | size_t | Дает наименьшее i такое, что p[i] == 0. Сложность линейна i . |
| v.translate(c) | X::char_type | Возвращает такой символ, что для любого символа, d который должен считаться эквивалентным c then v.translate(c) == v.translate(d). |
| v.translate_nocase(c) | X::char_type | Тогда для всех символов C , которые должны считаться эквивалентными, c когда сравнения должны выполняться без учета регистра v.translate_nocase(c) == v.translate_nocase(C). |
| v.transform(F1, F2) | X::string_type | Возвращает ключ сортировки для последовательности символов, обозначенной диапазоном итератора [F1, F2) , так что если последовательность символов [G1, G2) сортируется до последовательности символов, [H1, H2) тогда v.transform(G1, G2) < v.transform(H1, H2). |
| v.transform_primary(F1, F2) | X::string_type | Возвращает ключ сортировки для последовательности символов, обозначенной диапазоном итератора [F1, F2) , так что если последовательность символов [G1, G2) сортируется до последовательности [H1, H2) символов, тогда регистр символов не учитывается v.transform_primary(G1, G2) < v.transform_primary(H1, H2). |
| v.lookup_collatename(F1, F2) | X::string_type | Возвращает последовательность символов, представляющую элемент сортировки, состоящий из последовательности символов, обозначенной диапазоном итератора [F1, F2). Возвращает пустую строку, если последовательность символов не является допустимым элементом сортировки. |
| v.lookup_classname(F1, F2, b) | X::char_class_type | Преобразует последовательность символов, указанную диапазоном итератора, [F1, F2) в значение типа битовой маски, которое впоследствии может быть передано isctype. Значения, возвращаемые из, lookup_classname могут быть побитовыми или объединены вместе; результирующее значение представляет членство в любом из соответствующих классов символов. Если b есть true, то возвращаемая битовая маска подходит для сопоставления символов независимо от их регистра. Возвращает, 0 если последовательность символов не является именем класса символов, распознаваемого X. Возвращаемое значение не должно зависеть от регистра символов в последовательности. |
| v.isctype(c, cl) | bool | Возвращает, true если персонаж c является членом одного из классов символов, обозначенных cl, в false противном случае. |
| v.value(c, I) | int | Возвращает значение, представленное цифрой c в базе, I если символ c является допустимой цифрой в базе I; в противном случае возвращается -1. [ Note: Значение I будет только 8, 10 или 16. ] — end note |
| u.imbue(loc) | X::locale_type | Наполняет u языковой стандарт loc и возвращает предыдущий языковой стандарт, который использовался, u если он есть. |
| v.getloc() | X::locale_type | Возвращает текущий языковой стандарт v, если таковой имеется. |
| Элемент | Эффект (ы), если установлен |
| icase | Указывает, что сопоставление регулярных выражений с последовательностью контейнера символов должно выполняться без учета регистра. |
| nosubs | Указывает, что никакие подвыражения не должны считаться отмеченными, так что, когда регулярное выражение сопоставляется с последовательностью контейнера символов, совпадения подвыражений не должны сохраняться в предоставленной match_results структуре. |
| optimize | Указывает, что обработчик регулярных выражений должен уделять больше внимания скорости сопоставления регулярных выражений и меньше - скорости, с которой создаются объекты регулярных выражений. В противном случае это не оказывает заметного влияния на вывод программы. |
| collate | Указывает, что диапазоны символов формы "[a-b]" должны быть чувствительны к языку. |
| ECMAScript | Указывает, что грамматика, распознаваемая обработчиком регулярных выражений, должна соответствовать грамматике, используемой ECMAScript в ECMA-262, как изменено в [re.grammar]. |
| basic | Указывает, что грамматика, распознаваемая механизмом регулярных выражений, должна быть грамматикой, используемой базовыми регулярными выражениями в POSIX, Базовые определения и заголовки, Раздел 9, Регулярные выражения. |
| extended | Указывает, что грамматика, распознаваемая обработчиком регулярных выражений, должна быть грамматикой, используемой расширенными регулярными выражениями в POSIX, Базовые определения и заголовки, Раздел 9, Регулярные выражения. |
| awk | Указывает, что грамматика, распознаваемая обработчиком регулярных выражений, должна соответствовать грамматике, используемой утилитой awk в POSIX. |
| grep | Указывает, что грамматика, распознаваемая обработчиком регулярных выражений, должна соответствовать грамматике, используемой утилитой grep в POSIX. |
| egrep | Указывает, что грамматика, распознаваемая обработчиком регулярных выражений, должна соответствовать грамматике, используемой утилитой grep, если задана опция -E в POSIX. |
| multiline | Указывает, что ^ должно соответствовать началу строки и $ должно соответствовать концу строки, если ECMAScript выбран двигатель. |
| Элемент | Эффект (ы), если установлен |
| match_not_bol |
Первый символ в последовательности [first, last) следует рассматривать так, как будто он не находится в начале строки, поэтому символ
^ в регулярном выражении не должен совпадать [first, first).
|
| match_not_eol |
Последний символ в последовательности [first, last) должен рассматриваться так, как если бы он не находился в конце строки, поэтому символ
"$" в регулярном выражении не должен совпадать [last, last).
|
| match_not_bow |
Выражение "\\b" не должно соответствовать подпоследовательности [first, first).
|
| match_not_eow |
Выражение "\\b" не должно соответствовать подпоследовательности [last, last).
|
| match_any | Если возможно более одного совпадения, то приемлемым результатом будет любое совпадение. |
| match_not_null | Выражение не должно соответствовать пустой последовательности. |
| match_continuous | Выражение должно соответствовать только подпоследовательности, которая начинается с first. |
| match_prev_avail |
--first - допустимая позиция итератора. Когда этот флаг установлен, флаги match_not_bol и match_not_bow должны игнорироваться клавишами
regular expression algorithms и iterators.
|
| format_default | Когда совпадение регулярного выражения должно быть заменено новой строкой, новая строка должна быть построена с использованием правил, используемых функцией замены ECMAScript в ECMA-262, часть 15.5.4.11 String.prototype.replace. Кроме того, во время операций поиска и замены все неперекрывающиеся вхождения регулярного выражения должны быть обнаружены и заменены, а разделы ввода, которые не соответствуют выражению, должны быть скопированы без изменений в выходную строку. |
| format_sed | Когда совпадение регулярного выражения должно быть заменено новой строкой, новая строка должна быть построена с использованием правил, используемых утилитой sed в POSIX. |
| format_no_copy | Во время операции поиска и замены разделы просматриваемой последовательности контейнеров символов, которые не соответствуют регулярному выражению, не должны копироваться в выходную строку. |
| format_first_only | Если указано во время операции поиска и замены, заменяется только первое вхождение регулярного выражения. |
| Ценить | Состояние ошибки |
| error_collate | Выражение содержало недопустимое имя элемента сортировки. |
| error_ctype | Выражение содержало недопустимое имя класса символов. |
| error_escape | Выражение содержало недопустимый экранированный символ или завершающий escape-символ. |
| error_backref | Выражение содержит недопустимую обратную ссылку. |
| error_brack |
Выражение содержит несоответствующие [ и ]. |
| error_paren |
Выражение содержит несоответствующие ( и ). |
| error_brace |
Выражение содержало несоответствие { и } |
| error_badbrace |
Выражение содержит недопустимый диапазон в {} выражении. |
| error_range |
Выражение содержит недопустимый диапазон символов, как
[b-a] в большинстве кодировок. |
| error_space | Недостаточно памяти для преобразования выражения в конечный автомат. |
| error_badrepeat |
Одному из *?+{ не предшествовало действительное регулярное выражение. |
| error_complexity | Сложность попытки сопоставления с регулярным выражением превышает заранее установленный уровень. |
| error_stack | Недостаточно памяти для определения соответствия регулярного выражения указанной последовательности символов. |
| Узкое имя персонажа | Имя широкого символа | Соответствующее ctype_base::mask значение |
| "alnum" | L"alnum" | ctype_base::alnum |
| "alpha" | L"alpha" | ctype_base::alpha |
| "blank" | L"blank" | ctype_base::blank |
| "cntrl" | L"cntrl" | ctype_base::cntrl |
| "digit" | L"digit" | ctype_base::digit |
| "d" | L"d" | ctype_base::digit |
| "graph" | L"graph" | ctype_base::graph |
| "lower" | L"lower" | ctype_base::lower |
| "print" | L"print" | ctype_base::print |
| "punct" | L"punct" | ctype_base::punct |
| "space" | L"space" | ctype_base::space |
| "s" | L"s" | ctype_base::space |
| "upper" | L"upper" | ctype_base::upper |
| "w" | L"w" | ctype_base::alnum |
| "xdigit" | L"xdigit" | ctype_base::xdigit |
| Элемент | Ценить |
| ready() | m.ready() |
| size() | m.size() |
| str(n) | m.str(n) для всех целых чисел n < m.size() |
| prefix() | m.prefix() |
| suffix() | m.suffix() |
| (*this)[n] | m[n] для всех целых чисел n < m.size() |
| length(n) | m.length(n) для всех целых чисел n < m.size() |
| position(n) | m.position(n) для всех целых чисел n < m.size() |
| Элемент | Ценить |
| m.size() | 1 + e.mark_count() |
| m.empty() | false |
| m.prefix().first | first |
| m.prefix().second | first |
| m.prefix().matched | false |
| m.suffix().first | last |
| m.suffix().second | last |
| m.suffix().matched | false |
| m[0].first | first |
| m[0].second | last |
| m[0].matched | true |
| m[n].first | Для всех целых чисел 0 < n < m.size()- начало последовательности, соответствующей подвыражению n. В качестве альтернативы, если подвыражение n не участвовало в сопоставлении, тогда last. |
| m[n].second | Для всех целых чисел 0 < n < m.size()- конец последовательности, соответствующей подвыражению n. В качестве альтернативы, если подвыражение n не участвовало в сопоставлении, тогда last. |
| m[n].matched | Для всех целых чисел 0 < n < m.size(), true если n в совпадении участвовало подвыражение, в false противном случае. |
| Элемент | Ценить |
| m.size() | 1 + e.mark_count() |
| m.empty() | false |
| m.prefix().first | first |
| m.prefix().second | m[0].first |
| m.prefix().matched | m.prefix().first != m.prefix().second |
| m.suffix().first | m[0].second |
| m.suffix().second | last |
| m.suffix().matched | m.suffix().first != m.suffix().second |
| m[0].first | Начало последовательности символов, соответствующих регулярному выражению. |
| m[0].second | Конец последовательности символов, соответствующей регулярному выражению. |
| m[0].matched | true |
| m[n].first | Для всех целых чисел 0 < n < m.size()- начало последовательности, соответствующей подвыражению n. В качестве альтернативы, если подвыражение n не участвовало в сопоставлении, тогда last. |
| m[n].second | Для всех целых чисел 0 < n < m.size()- конец последовательности, соответствующей подвыражению n. В качестве альтернативы, если подвыражение n не участвовало в сопоставлении, тогда last . |
| m[n].matched | Для всех целых чисел 0 < n < m.size(), true если n в совпадении участвовало подвыражение, в false противном случае. |
| Подпункт | Заголовок (ы) | |
| [atomics.order] | Порядок и последовательность | |
| [atomics.lockfree] | Замок-свободная собственность | |
| [atomics.types.generic] | Атомные типы | <atomic> |
| [atomics.types.operations] | Операции с атомными типами | |
| [atomics.flag] | Тип флага и операции | |
| [atomics.fences] | Заборы | |
| key | Op | Вычисление | key | Op | Вычисление |
| add | + | добавление | sub | - | вычитание |
| or | | | побитовое включение или | xor | ^ | побитовое исключающее или |
| and | & | побитовое и |
| Key | Op | Вычисление | Key | Op | Вычисление |
| add | + | добавление | sub | - | вычитание |
| Подпункт | Заголовок (ы) | |
| [thread.req] | Требования | |
| [thread.threads] | Потоки | <thread> |
| [thread.mutex] | Взаимное исключение | <mutex> |
| <shared_mutex> | ||
| [thread.condition] | Переменные условия | <condition_variable> |
| [futures] | Фьючерсы | <future> |
| <assert.h> | <inttypes.h> | <signal.h> | <stdio.h> | <wchar.h> |
| <complex.h> | <iso646.h> | <stdalign.h> | <stdlib.h> | <wctype.h> |
| <ctype.h> | <limits.h> | <stdarg.h> | <string.h> | |
| <errno.h> | <locale.h> | <stdbool.h> | <tgmath.h> | |
| <fenv.h> | <math.h> | <stddef.h> | <time.h> | |
| <float.h> | <setjmp.h> | <stdint.h> | <uchar.h> |
| Элемент | Ценить |
| strmode | dynamic |
| alsize | alsize_arg |
| palloc | нулевой указатель |
| pfree | нулевой указатель |
| Элемент | Ценить |
| strmode | dynamic |
| alsize | неуказанное значение |
| palloc | palloc_arg |
| pfree | pfree_arg |
| Элемент | Ценить |
| strmode | 0 |
| alsize | неуказанное значение |
| palloc | нулевой указатель |
| pfree | нулевой указатель |
| Условия | Результат |
| (which & ios::in) != 0 | позиционирует входную последовательность |
| (which & ios::out) != 0 | позиционирует выходную последовательность |
|
(which & (ios::in | ios::out)) == (ios::in | ios::out)) и way == либо, ios::beg либо ios::end | позиционирует как входную, так и выходную последовательности |
| Иначе | операция позиционирования не выполняется. |
| Состояние | newoff Ценить |
| way == ios::beg | 0 |
| way == ios::cur | следующий указатель минус указатель начала ( xnext - xbeg). |
| way == ios::end | seekhigh минус начальный указатель ( seekhigh - xbeg). |