21 Language support library [language.support]

21.1 General [support.general]

В этом разделе описаны сигнатуры функций, которые вызываются неявно, и типы объектов, генерируемых неявно во время выполнения некоторых программ C ++. Он также описывает заголовки, которые объявляют эти сигнатуры функций и определяют любые связанные типы.

В следующих подпунктах описываются определения общих типов, используемых в библиотеке, характеристики предопределенных типов, функции, поддерживающие запуск и завершение программы C ++, поддержку динамического управления памятью, поддержку идентификации динамического типа, поддержку обработки исключений, поддержку списков инициализаторов, и другая поддержка времени выполнения, как показано в Табл 32.

Таблица 32 - Сводная информация о библиотеке поддержки языков

Подпункт		Заголовок (ы)
[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>

21.2 Common definitions [support.types]

21.2.1 Header <cstddef> synopsis [cstddef.syn]

namespace std {
  using ptrdiff_t = see below;
  using size_t = see below;
  using max_align_t = see below;
  using nullptr_t = decltype(nullptr);

  enum class byte : unsigned char {};

  // [support.types.byteops], byte type operations
  template <class IntType>
    constexpr byte& operator<<=(byte& b, IntType shift) noexcept;
  template <class IntType>
    constexpr byte operator<<(byte b, IntType shift) noexcept;
  template <class IntType>
    constexpr byte& operator>>=(byte& b, IntType shift) noexcept;
  template <class IntType>
    constexpr byte operator>>(byte b, IntType shift) noexcept;
  constexpr byte& operator|=(byte& l, byte r) noexcept;
  constexpr byte operator|(byte l, byte r) noexcept;
  constexpr byte& operator&=(byte& l, byte r) noexcept;
  constexpr byte operator&(byte l, byte r) noexcept;
  constexpr byte& operator^=(byte& l, byte r) noexcept;
  constexpr byte operator^(byte l, byte r) noexcept;
  constexpr byte operator~(byte b) noexcept;
  template <class IntType>
    constexpr IntType to_integer(byte b) noexcept;
}

#define NULL see below
#define offsetof(P, D) see below

Содержимое и значение заголовка <cstddef> такие же, как и у заголовка стандартной библиотеки C <stddef.h>, за исключением того, что он не объявляет тип wchar_t, он также объявляет тип byte и связанные с ним операции ([support.types.byteops]), и, как указано в [support.types.nullptr] и [support.types.layout].

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

21.2.2 Header <cstdlib> synopsis [cstdlib.syn]

namespace std {
  using size_t = see below;
  using div_t = see below;
  using ldiv_t = see below;
  using lldiv_t = see below;
}

#define NULL see below
#define EXIT_FAILURE see below
#define EXIT_SUCCESS see below
#define RAND_MAX see below
#define MB_CUR_MAX see below

namespace std {
  // Exposition-only function type aliases
  extern "C" using c-atexit-handler = void();                        // exposition only
  extern "C++" using atexit-handler = void();                        // exposition only
  extern "C" using c-compare-pred = int(const void*, const void*);   // exposition only
  extern "C++" using compare-pred = int(const void*, const void*);   // exposition only

  // [support.start.term], start and termination
  [[noreturn]] void abort() noexcept;
  int atexit(c-atexit-handler* func) noexcept;
  int atexit(atexit-handler* func) noexcept;
  int at_quick_exit(c-atexit-handler* func) noexcept;
  int at_quick_exit(atexit-handler* func) noexcept;
  [[noreturn]] void exit(int status);
  [[noreturn]] void _Exit(int status) noexcept;
  [[noreturn]] void quick_exit(int status) noexcept;

  char* getenv(const char* name);
  int system(const char* string);

  // [c.malloc], C library memory allocation
  void* aligned_alloc(size_t alignment, size_t size);
  void* calloc(size_t nmemb, size_t size);
  void free(void* ptr);
  void* malloc(size_t size);
  void* realloc(void* ptr, size_t size);

  double atof(const char* nptr);
  int atoi(const char* nptr);
  long int atol(const char* nptr);
  long long int atoll(const char* nptr);
  double strtod(const char* nptr, char** endptr);
  float strtof(const char* nptr, char** endptr);
  long double strtold(const char* nptr, char** endptr);
  long int strtol(const char* nptr, char** endptr, int base);
  long long int strtoll(const char* nptr, char** endptr, int base);
  unsigned long int strtoul(const char* nptr, char** endptr, int base);
  unsigned long long int strtoull(const char* nptr, char** endptr, int base);

  // [c.mb.wcs], multibyte / wide string and character conversion functions
  int mblen(const char* s, size_t n);
  int mbtowc(wchar_t* pwc, const char* s, size_t n);
  int wctomb(char* s, wchar_t wchar);
  size_t mbstowcs(wchar_t* pwcs, const char* s, size_t n);
  size_t wcstombs(char* s, const wchar_t* pwcs, size_t n);

  // [alg.c.library], C standard library algorithms
  void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
                c-compare-pred* compar);
  void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
                compare-pred* compar);
  void qsort(void* base, size_t nmemb, size_t size, c-compare-pred* compar);
  void qsort(void* base, size_t nmemb, size_t size, compare-pred* compar);

  // [c.math.rand], low-quality random number generation
  int rand();
  void srand(unsigned int seed);

  // [c.math.abs], absolute values
  int abs(int j);
  long int abs(long int j);
  long long int abs(long long int j);
  float abs(float j);
  double abs(double j);
  long double abs(long double j);

  long int labs(long int j);
  long long int llabs(long long int j);

  div_t div(int numer, int denom);
  ldiv_t div(long int numer, long int denom);             // see [library.c]
  lldiv_t div(long long int numer, long long int denom);  // see [library.c]
  ldiv_t ldiv(long int numer, long int denom);
  lldiv_t lldiv(long long int numer, long long int denom);
}

Содержание и значение заголовка <cstdlib> такие же , как стандартный заголовок библиотеки C <stdlib.h>, за исключением того, что он не объявить тип wchar_t, и за исключением того, как было отмечено в [support.types.nullptr], [support.types.layout], [support.start.term], [c.malloc], [c.mb.wcs], [alg.c.library], [c.math.rand], и [c.math.abs]. [ Note: Некоторые функции имеют дополнительные перегрузки в этом международном стандарте, но их поведение такое же, как и в C standard library. ] — end note

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

21.2.3 Null pointers [support.types.nullptr]

Тип nullptr_tявляется синонимом типа nullptr выражения и имеет характеристики, описанные в [basic.fundamental] и [conv.ptr]. [ Note: Хотя nullptrадрес не может быть взят, адрес другого nullptr_t объекта, который является lvalue, может быть взят. ] — end note

Макрос NULL представляет собой константу нулевого указателя, определяемую реализацией.186

186)

Возможные определения включают 0 и 0L, но не (void*)0.

21.2.4 Sizes, alignments, and offsets [support.types.layout]

Макрос offsetof(type, member-designator) имеет ту же семантику, что и соответствующий макрос в заголовке стандартной библиотеки C <stddef.h>, но принимает ограниченный набор type аргументов в этом международном стандарте. Условно поддерживается использование offsetof макроса с type отличным от a standard-layout class.187 Выражение offsetof(type, member-designator) никогда не бывает, type-dependent и оно value-dependent тогда и только тогда, когда type является зависимым. Результат применения offsetof макроса к статическому элементу данных или члену функции не определен. Никакая операция, вызванная offsetof макросом, неnoexcept(offsetof(type, member-designator)) должна вызывать исключение true.

Тип ptrdiff_t представляет собой определяемый реализацией целочисленный тип со знаком, который может содержать разницу двух нижних индексов в объекте массива, как описано в [expr.add].

Тип size_t представляет собой определяемый реализацией целочисленный тип без знака, который достаточно велик, чтобы содержать размер в байтах любого объекта.

[ Note: Рекомендуется, чтобы реализации выбирали типы для ptrdiff_t и size_t , целое число conversion ranks которых не больше, чем у, signed long int если только больший размер не требуется для хранения всех возможных значений. ] — end note

Тип max_align_t представляет собой POD-тип, требования к выравниванию которого не менее велики, чем требования любого скалярного типа, и чьи требования к выравниванию поддерживаются в каждом контексте.

Смотрите также: Alignment, Sizeof, Additive operators, Free store, и ISO C 7,19.

187)

Обратите внимание, что offsetof требуется для работы, как указано, даже если унарный operator& перегружен для любого из задействованных типов.

21.2.5 byte type operations [support.types.byteops]

template <class IntType> constexpr byte& operator<<=(byte& b, IntType shift) noexcept;

Remarks: Эта функция не будет участвовать в разрешении перегрузки , если is_integral_v<IntType> не true.

Effects: Эквивалентен: return b = byte(static_cast<unsigned char>(b) << shift);

template <class IntType> constexpr byte operator<<(byte b, IntType shift) noexcept;

Remarks: Эта функция не будет участвовать в разрешении перегрузки , если is_integral_v<IntType> не true.

Effects: Эквивалентен: return byte(static_cast<unsigned char>(b) << shift);

template <class IntType> constexpr byte& operator>>=(byte& b, IntType shift) noexcept;

Remarks: Эта функция не будет участвовать в разрешении перегрузки , если is_integral_v<IntType> не true.

Effects: Эквивалентен: return b = byte(static_cast<unsigned char>(b) >> shift);

template <class IntType> constexpr byte operator>>(byte b, IntType shift) noexcept;

Remarks: Эта функция не будет участвовать в разрешении перегрузки , если is_integral_v<IntType> не true.

Effects: Эквивалентен: return byte(static_cast<unsigned char>(b) >> shift);

constexpr byte& operator|=(byte& l, byte r) noexcept;

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

return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));

constexpr byte operator|(byte l, byte r) noexcept;

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

return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));

constexpr byte& operator&=(byte& l, byte r) noexcept;

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

return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));

constexpr byte operator&(byte l, byte r) noexcept;

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

return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));

constexpr byte& operator^=(byte& l, byte r) noexcept;

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

return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));

constexpr byte operator^(byte l, byte r) noexcept;

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

return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));

constexpr byte operator~(byte b) noexcept;

Effects: Эквивалентен: return byte(~static_cast<unsigned char>(b));

template <class IntType> constexpr IntType to_integer(byte b) noexcept;

Remarks: Эта функция не будет участвовать в разрешении перегрузки , если is_integral_v<IntType> не true.

Effects: Эквивалентен: return IntType(b);

21.3 Implementation properties [support.limits]

21.3.1 General [support.limits.general]

Заголовки <limits>, <climits>и <cfloat> предоставляют характеристики арифметических типов, зависящих от реализации ([basic.fundamental]).

21.3.2 Header <limits> synopsis [limits.syn]

namespace std {
  // [fp.style], floating-point type properties
  enum float_round_style;
  enum float_denorm_style;

  // [numeric.limits], class template numeric_limits
  template<class T> class numeric_limits;

  template<> class numeric_limits<bool>;

  template<> class numeric_limits<char>;
  template<> class numeric_limits<signed char>;
  template<> class numeric_limits<unsigned char>;
  template<> class numeric_limits<char16_t>;
  template<> class numeric_limits<char32_t>;
  template<> class numeric_limits<wchar_t>;

  template<> class numeric_limits<short>;
  template<> class numeric_limits<int>;
  template<> class numeric_limits<long>;
  template<> class numeric_limits<long long>;
  template<> class numeric_limits<unsigned short>;
  template<> class numeric_limits<unsigned int>;
  template<> class numeric_limits<unsigned long>;
  template<> class numeric_limits<unsigned long long>;

  template<> class numeric_limits<float>;
  template<> class numeric_limits<double>;
  template<> class numeric_limits<long double>;
}

21.3.3 Floating-point type properties [fp.style]

21.3.3.1 Type float_round_style [round.style]

namespace std {
  enum float_round_style {
    round_indeterminate       = -1,
    round_toward_zero         =  0,
    round_to_nearest          =  1,
    round_toward_infinity     =  2,
    round_toward_neg_infinity =  3
  };
}

Режим округления для арифметики с плавающей запятой характеризуется значениями:

(1.1)
round_indeterminate если стиль округления не определен
(1.2)
round_toward_zero если стиль округления приближается к нулю
(1.3)
round_to_nearest если стиль округления - до ближайшего представимого значения
(1.4)
round_toward_infinity если стиль округления стремится к бесконечности
(1.5)
round_toward_neg_infinity если стиль округления направлен к отрицательной бесконечности

21.3.3.2 Type float_denorm_style [denorm.style]

namespace std {
  enum float_denorm_style {
    denorm_indeterminate = -1,
    denorm_absent = 0,
    denorm_present = 1
  };
}

Наличие или отсутствие субнормальных чисел (переменное количество разрядов экспоненты) характеризуется значениями:

(1.1)
denorm_indeterminate если невозможно определить, допускает ли тип субнормальные значения
(1.2)
denorm_absent если тип не допускает субнормальных значений
(1.3)
denorm_present если тип допускает субнормальные значения

21.3.4 Class template numeric_limits [numeric.limits]

numeric_limits Шаблонный класс предоставляет программу на C ++ с информацией о различных свойствах репрезентации реализации языка арифметических типов.

namespace std {
  template<class T> class numeric_limits {
  public:
    static constexpr bool is_specialized = false;
    static constexpr T min() noexcept { return T(); }
    static constexpr T max() noexcept { return T(); }
    static constexpr T lowest() noexcept { return T(); }

    static constexpr int  digits = 0;
    static constexpr int  digits10 = 0;
    static constexpr int  max_digits10 = 0;
    static constexpr bool is_signed = false;
    static constexpr bool is_integer = false;
    static constexpr bool is_exact = false;
    static constexpr int  radix = 0;
    static constexpr T epsilon() noexcept { return T(); }
    static constexpr T round_error() noexcept { return T(); }

    static constexpr int  min_exponent = 0;
    static constexpr int  min_exponent10 = 0;
    static constexpr int  max_exponent = 0;
    static constexpr int  max_exponent10 = 0;

    static constexpr bool has_infinity = false;
    static constexpr bool has_quiet_NaN = false;
    static constexpr bool has_signaling_NaN = false;
    static constexpr float_denorm_style has_denorm = denorm_absent;
    static constexpr bool has_denorm_loss = false;
    static constexpr T infinity() noexcept { return T(); }
    static constexpr T quiet_NaN() noexcept { return T(); }
    static constexpr T signaling_NaN() noexcept { return T(); }
    static constexpr T denorm_min() noexcept { return T(); }

    static constexpr bool is_iec559 = false;
    static constexpr bool is_bounded = false;
    static constexpr bool is_modulo = false;

    static constexpr bool traps = false;
    static constexpr bool tinyness_before = false;
    static constexpr float_round_style round_style = round_toward_zero;
  };

  template<class T> class numeric_limits<const T>;
  template<class T> class numeric_limits<volatile T>;
  template<class T> class numeric_limits<const volatile T>;
}

Для всех членов, объявленных static constexpr в numeric_limits шаблоне, специализации должны определять эти значения таким образом, чтобы их можно было использовать как постоянные выражения.

Вnumeric_limits<T> шаблоне по умолчанию должны быть все элементы, но с 0 или false значениями.

Спецификации должны быть предоставлены для каждого арифметического типа, включая числа с плавающей запятой и целые числа bool. Член is_specialized должен быть true для всех таких специальностей numeric_limits.

Значение каждого члена специализации numeric_limits неквалифицированного типа cv T должно быть равно значению соответствующего члена специализации неквалифицированного типа T.

Стандартные неарифметические типы, такие как complex<T>, не должны иметь специализаций.

21.3.4.1 numeric_limits members [numeric.limits.members]

Каждая функция-член, определенная в этом подпункте, является signal-safe ([csignal.syn]).

static constexpr T min() noexcept;

Минимальное конечное значение.188

Для типов с плавающей запятой с субнормальными числами возвращает минимальное положительное нормализованное значение.

Имеет значение для всех специализаций, в которых is_bounded != false, или is_bounded == false && is_signed == false.

static constexpr T max() noexcept;

Максимальное конечное значение.189

Имеет значение для всех специализаций, в которых is_bounded != false.

static constexpr T lowest() noexcept;

Конечное значение x такое, что не существует другого конечного значения y где y < x.190

Имеет значение для всех специализаций, в которых is_bounded != false.

static constexpr int digits;

Количество radix цифр, которое можно представить без изменений.

Для целочисленных типов - количество битов без знака в представлении.

Для типов с плавающей запятой - количество radix цифр в мантиссе.191

static constexpr int digits10;

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

Имеет значение для всех специализаций, в которых is_bounded != false.

static constexpr int max_digits10;

Количество десятичных разрядов, необходимое для того, чтобы всегда различать различающиеся значения.

Имеет значение для всех типов с плавающей запятой.

static constexpr bool is_signed;

true если тип подписан.

Имеет значение для всех специализаций.

static constexpr bool is_integer;

true если тип целочисленный.

Имеет значение для всех специализаций.

static constexpr bool is_exact;

true если тип использует точное представление. Все целочисленные типы являются точными, но не все точные типы являются целыми числами. Например, рациональные представления и представления с фиксированным показателем являются точными, но не целочисленными.

Имеет значение для всех специализаций.

static constexpr int radix;

Для типов с плавающей запятой указывает основание или основание системы счисления экспоненты (часто 2).193

Для целочисленных типов указывает основу представления.194

Имеет значение для всех специализаций.

static constexpr T epsilon() noexcept;

Машинный эпсилон: разница между 1 и наименьшим представимым значением больше 1.195

Имеет значение для всех типов с плавающей запятой.

static constexpr T round_error() noexcept;

Мера максимальной ошибки округления.196

static constexpr int min_exponent;

Минимальное отрицательное целое число, radix возведенное в степень на единицу меньше этого целого, является нормализованным числом с плавающей запятой.197

Имеет значение для всех типов с плавающей запятой.

static constexpr int min_exponent10;

Минимальное отрицательное целое число, при котором 10 в этой степени находится в диапазоне нормализованных чисел с плавающей запятой.198

Имеет значение для всех типов с плавающей запятой.

static constexpr int max_exponent;

Максимальное положительное целое число, radix возведенное в степень на единицу меньше этого целого, является представимым конечным числом с плавающей запятой.199

Имеет значение для всех типов с плавающей запятой.

static constexpr int max_exponent10;

Максимальное положительное целое число, такое, что 10 в этой степени находится в диапазоне представимых конечных чисел с плавающей запятой.200

Имеет значение для всех типов с плавающей запятой.

static constexpr bool has_infinity;

true если тип имеет представление для положительной бесконечности.

Имеет значение для всех типов с плавающей запятой.

Должен быть true для всех специализаций, в которых is_iec559 != false.

static constexpr bool has_quiet_NaN;

true если тип имеет представление для тихого (не сигнализирующего) «Not a Number».201

Имеет значение для всех типов с плавающей запятой.

Должен быть true для всех специализаций, в которых is_iec559 != false.

static constexpr bool has_signaling_NaN;

true если тип имеет представление для сигнализации «Not a Number».202

Имеет значение для всех типов с плавающей запятой.

Должен быть true для всех специализаций, в которых is_iec559 != false.

static constexpr float_denorm_style has_denorm;

denorm_present если тип допускает субнормальные значения (переменное количество битов экспоненты)203, denorm_absent если тип не допускает субнормальных значений, и denorm_indeterminate если он не определен во время компиляции, допускает ли тип субнормальные значения.

Имеет значение для всех типов с плавающей запятой.

static constexpr bool has_denorm_loss;

true если потеря точности определяется как потеря денормализации, а не как неточный результат.204

static constexpr T infinity() noexcept;

Представление положительной бесконечности, если доступно.205

Имеет значение для всех специализаций, для которых has_infinity != false. Обязателен в специализациях, для которых is_iec559 != false.

static constexpr T quiet_NaN() noexcept;

Представление тихого «Не числа», если доступно.206

Имеет значение для всех специализаций, для которых has_quiet_NaN != false. Обязателен в специализациях, для которых is_iec559 != false.

static constexpr T signaling_NaN() noexcept;

Отображение сигнализации «Не число», если таковая имеется.207

Имеет значение для всех специализаций, для которых has_signaling_NaN != false. Обязателен в специализациях, для которых is_iec559 != false.

static constexpr T denorm_min() noexcept;

Минимальное положительное субнормальное значение.208

Имеет значение для всех типов с плавающей запятой.

В специализациях, для которых has_denorm == falseвозвращает минимальное положительное нормализованное значение.

static constexpr bool is_iec559;

true тогда и только тогда, когда тип соответствует ISO / IEC / IEEE 60559.209

Имеет значение для всех типов с плавающей запятой.

static constexpr bool is_bounded;

true если набор значений, представимых типом, конечно.210 [ Note: Все фундаментальные типы ([basic.fundamental]) ограничены. Этот член предназначен false для типов произвольной точности. ] — end note

Имеет значение для всех специализаций.

static constexpr bool is_modulo;

true если тип по модулю.211 Тип определяется по модулю, если для любой операции с участием +, -или * со значениями этого типа, результат которых выходит за пределы диапазона [min(), max()], возвращаемое значение отличается от истинного значения на целое число, кратное max() - min() + 1.

[ Example: is_modulo предназначен false для целочисленных типов со знаком ([basic.fundamental]), если реализация, как расширение этого международного стандарта, не определяет целочисленное переполнение со знаком для переноса. ] — end example

Имеет значение для всех специализаций.

static constexpr bool traps;

true если при запуске программы существует значение типа, которое вызовет арифметическую операцию с использованием этого значения для перехвата.212

Имеет значение для всех специализаций.

static constexpr bool tinyness_before;

true если крошечность обнаружена до округления.213

Имеет значение для всех типов с плавающей запятой.

static constexpr float_round_style round_style;

Стиль округления для шрифта.214

Имеет значение для всех типов с плавающей запятой. Должны возвращаться специализации для целочисленных типов round_toward_zero.

188)

Эквивалент CHAR_MIN, SHRT_MIN, FLT_MIN, DBL_MINи т.д.

189)

Эквивалент CHAR_MAX, SHRT_MAX, FLT_MAX, DBL_MAXи т.д.

190)

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

191)

Эквивалент FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG.

192)

Эквивалент FLT_DIG, DBL_DIG, LDBL_DIG.

193)

Эквивалентно FLT_RADIX.

194)

Различает типы с основанием, отличным от 2 (например, BCD).

195)

Эквивалент FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON.

196)

Ошибка округления описана в разделе 5.2.4 LIA-1 и разделе C.5.2.4 «Обоснование» приложения C. - Округление и константы округления.

197)

Эквивалент FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP.

198)

Эквивалент FLT_MIN_10_EXP, DBL_MIN_10_EXP, LDBL_MIN_10_EXP.

199)

Эквивалент FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP.

200)

Эквивалент FLT_MAX_10_EXP, DBL_MAX_10_EXP, LDBL_MAX_10_EXP.

Требуется LIA-1.

Требуется LIA-1.

Требуется LIA-1.

См. ISO / IEC / IEEE 60559.

Требуется LIA-1.

Требуется LIA-1.

Требуется LIA-1.

Требуется LIA-1.

ISO / IEC / IEEE 60559: 2011 совпадает с IEEE 754-2008.

Требуется LIA-1.

Требуется LIA-1.

Требуется LIA-1.

См. ISO / IEC / IEEE 60559. Требуется LIA-1.

214)

Эквивалентно FLT_ROUNDS. Требуется LIA-1.

21.3.4.2 numeric_limits specializations [numeric.special]

Предусмотрены все участники для всех специальностей. Однако многие значения должны быть значимыми только при определенных условиях (например, epsilon() имеет смысл только в том случае, если is_integer есть false). Любое значение, которое не является «значимым», должно быть установлено на 0 или false.

[ Example:

namespace std {
  template<> class numeric_limits<float> {
  public:
    static constexpr bool is_specialized = true;

    static constexpr float min() noexcept { return 1.17549435E-38F; }
    static constexpr float max() noexcept { return 3.40282347E+38F; }
    static constexpr float lowest() noexcept { return -3.40282347E+38F; }

    static constexpr int digits   = 24;
    static constexpr int digits10 =  6;
    static constexpr int max_digits10 =  9;

    static constexpr bool is_signed  = true;
    static constexpr bool is_integer = false;
    static constexpr bool is_exact   = false;

    static constexpr int radix = 2;
    static constexpr float epsilon() noexcept     { return 1.19209290E-07F; }
    static constexpr float round_error() noexcept { return 0.5F; }

    static constexpr int min_exponent   = -125;
    static constexpr int min_exponent10 = - 37;
    static constexpr int max_exponent   = +128;
    static constexpr int max_exponent10 = + 38;

    static constexpr bool has_infinity             = true;
    static constexpr bool has_quiet_NaN            = true;
    static constexpr bool has_signaling_NaN        = true;
    static constexpr float_denorm_style has_denorm = denorm_absent;
    static constexpr bool has_denorm_loss          = false;

    static constexpr float infinity()      noexcept { return value; }
    static constexpr float quiet_NaN()     noexcept { return value; }
    static constexpr float signaling_NaN() noexcept { return value; }
    static constexpr float denorm_min()    noexcept { return min(); }

    static constexpr bool is_iec559  = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo  = false;
    static constexpr bool traps      = true;
    static constexpr bool tinyness_before = true;

    static constexpr float_round_style round_style = round_to_nearest;
  };
}

— end example ]

Специализация bool предоставляется следующим образом:

namespace std {
   template<> class numeric_limits<bool> {
   public:
     static constexpr bool is_specialized = true;
     static constexpr bool min() noexcept { return false; }
     static constexpr bool max() noexcept { return true; }
     static constexpr bool lowest() noexcept { return false; }

     static constexpr int  digits = 1;
     static constexpr int  digits10 = 0;
     static constexpr int  max_digits10 = 0;

     static constexpr bool is_signed = false;
     static constexpr bool is_integer = true;
     static constexpr bool is_exact = true;
     static constexpr int  radix = 2;
     static constexpr bool epsilon() noexcept { return 0; }
     static constexpr bool round_error() noexcept { return 0; }

     static constexpr int  min_exponent = 0;
     static constexpr int  min_exponent10 = 0;
     static constexpr int  max_exponent = 0;
     static constexpr int  max_exponent10 = 0;

     static constexpr bool has_infinity = false;
     static constexpr bool has_quiet_NaN = false;
     static constexpr bool has_signaling_NaN = false;
     static constexpr float_denorm_style has_denorm = denorm_absent;
     static constexpr bool has_denorm_loss = false;
     static constexpr bool infinity() noexcept { return 0; }
     static constexpr bool quiet_NaN() noexcept { return 0; }
     static constexpr bool signaling_NaN() noexcept { return 0; }
     static constexpr bool denorm_min() noexcept { return 0; }

     static constexpr bool is_iec559 = false;
     static constexpr bool is_bounded = true;
     static constexpr bool is_modulo = false;

     static constexpr bool traps = false;
     static constexpr bool tinyness_before = false;
     static constexpr float_round_style round_style = round_toward_zero;
   };
}

21.3.5 Header <climits> synopsis [climits.syn]

#define CHAR_BIT see below
#define SCHAR_MIN see below
#define SCHAR_MAX see below
#define UCHAR_MAX see below
#define CHAR_MIN see below
#define CHAR_MAX see below
#define MB_LEN_MAX see below
#define SHRT_MIN see below
#define SHRT_MAX see below
#define USHRT_MAX see below
#define INT_MIN see below
#define INT_MAX see below
#define UINT_MAX see below
#define LONG_MIN see below
#define LONG_MAX see below
#define ULONG_MAX see below
#define LLONG_MIN see below
#define LLONG_MAX see below
#define ULLONG_MAX see below

Заголовка <climits> определяет все макросы такие же , как заголовок стандартной библиотеки C <limits.h>. [ Note: Типы констант, определенных макросами в <climits> , не обязательно должны соответствовать типам, на которые ссылаются макросы. ] — end note

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

21.3.6 Header <cfloat> synopsis [cfloat.syn]

#define FLT_ROUNDS see below
#define FLT_EVAL_METHOD see below
#define FLT_HAS_SUBNORM see below
#define DBL_HAS_SUBNORM see below
#define LDBL_HAS_SUBNORM see below
#define FLT_RADIX see below
#define FLT_MANT_DIG see below
#define DBL_MANT_DIG see below
#define LDBL_MANT_DIG see below
#define FLT_DECIMAL_DIG see below
#define DBL_DECIMAL_DIG see below
#define LDBL_DECIMAL_DIG see below
#define DECIMAL_DIG see below
#define FLT_DIG see below
#define DBL_DIG see below
#define LDBL_DIG see below
#define FLT_MIN_EXP see below
#define DBL_MIN_EXP see below
#define LDBL_MIN_EXP see below
#define FLT_MIN_10_EXP see below
#define DBL_MIN_10_EXP see below
#define LDBL_MIN_10_EXP see below
#define FLT_MAX_EXP see below
#define DBL_MAX_EXP see below
#define LDBL_MAX_EXP see below
#define FLT_MAX_10_EXP see below
#define DBL_MAX_10_EXP see below
#define LDBL_MAX_10_EXP see below
#define FLT_MAX see below
#define DBL_MAX see below
#define LDBL_MAX see below
#define FLT_EPSILON see below
#define DBL_EPSILON see below
#define LDBL_EPSILON see below
#define FLT_MIN see below
#define DBL_MIN see below
#define LDBL_MIN see below
#define FLT_TRUE_MIN see below
#define DBL_TRUE_MIN see below
#define LDBL_TRUE_MIN see below

Заголовка <cfloat> определяет все макросы такие же , как заголовок стандартной библиотеки C <float.h>.

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

21.4 Integer types [cstdint]

21.4.1 Header <cstdint> synopsis [cstdint.syn]

namespace std {
  using int8_t         = signed integer type;  // optional
  using int16_t        = signed integer type;  // optional
  using int32_t        = signed integer type;  // optional
  using int64_t        = signed integer type;  // optional

  using int_fast8_t    = signed integer type;
  using int_fast16_t   = signed integer type;
  using int_fast32_t   = signed integer type;
  using int_fast64_t   = signed integer type;

  using int_least8_t   = signed integer type;
  using int_least16_t  = signed integer type;
  using int_least32_t  = signed integer type;
  using int_least64_t  = signed integer type;

  using intmax_t       = signed integer type;
  using intptr_t       = signed integer type;   // optional

  using uint8_t        = unsigned integer type; // optional
  using uint16_t       = unsigned integer type; // optional
  using uint32_t       = unsigned integer type; // optional
  using uint64_t       = unsigned integer type; // optional

  using uint_fast8_t   = unsigned integer type;
  using uint_fast16_t  = unsigned integer type;
  using uint_fast32_t  = unsigned integer type;
  using uint_fast64_t  = unsigned integer type;

  using uint_least8_t  = unsigned integer type;
  using uint_least16_t = unsigned integer type;
  using uint_least32_t = unsigned integer type;
  using uint_least64_t = unsigned integer type;

  using uintmax_t      = unsigned integer type;
  using uintptr_t      = unsigned integer type; // optional
}

Заголовок также определяет многочисленные макросы формы:

  INT_[FAST LEAST]{8 16 32 64}_MIN
  [U]INT_[FAST LEAST]{8 16 32 64}_MAX
  INT{MAX PTR}_MIN
  [U]INT{MAX PTR}_MAX
  {PTRDIFF SIG_ATOMIC WCHAR WINT}{_MAX _MIN}
  SIZE_MAX

плюс функциональные макросы вида:

  [U]INT{8 16 32 64 MAX}_C

Заголовок определяет все типы и макросы так же , как заголовок стандартной библиотеки C <stdint.h>.

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

21.5 Start and termination [support.start.term]

[ Note: Заголовок <cstdlib> объявляет функции, описанные в этом подпункте. ] — end note

[[noreturn]] void _Exit(int status) noexcept;

Effects: Эта функция имеет семантику, указанную в стандартной библиотеке C.

Remarks: Программа завершается без выполнения деструкторов для объектов с автоматической, поточной или статической продолжительностью хранения и без вызова функций, переданных в atexit() ([basic.start.term]). Функция _Exit безопасна для сигналов ([csignal.syn]).

[[noreturn]] void abort() noexcept;

Effects: Эта функция имеет семантику, указанную в стандартной библиотеке C.

Remarks: Программа завершается без выполнения деструкторов для объектов с автоматической, поточной или статической продолжительностью хранения и без вызова функций, переданных в atexit() ([basic.start.term]). Функция abort безопасна для сигналов ([csignal.syn]).

int atexit(c-atexit-handler* f) noexcept; int atexit(atexit-handler* f) noexcept;

Effects: В atexit() функции регистрации функции , на которую указывает f называть без аргументов при нормальном завершении программы. Не определено , является ли вызов atexit() делает это не happen before вызов exit() преуспеет. [ Note: Эти atexit() функции не вводить гонки данных ([res.on.data.races]). ] — end note

Implementation limits: Реализация должна поддерживать регистрацию не менее 32 функций.

Returns: В atexit() Функции возвращает ноль , если регистрация прошла успешно, отлично от нуля , если он выходит из строя.

[[noreturn]] void exit(int status);

Effects:

(9.1)
Сначала уничтожаются объекты с длительностью хранения потока, связанные с текущим потоком. Затем объекты со статической продолжительностью хранения уничтожаются и вызываются функции, зарегистрированные при вызове atexit .215 Смотрите [basic.start.term] порядок разрушений и вызовов. (Автоматические объекты не уничтожаются в результате вызова exit().)216
Если элемент управления оставляет зарегистрированную функцию, вызванную, exit потому что функция не предоставляет обработчик для возникшего исключения, std::terminate() должна быть вызвана ([except.terminate]).
(9.2)
Затем все открытые потоки C (опосредованные сигнатурами функций, объявленными в <cstdio>) с незаписанными буферизованными данными сбрасываются, все открытые потоки C закрываются, а все файлы, созданные в результате вызова tmpfile() , удаляются.
(9.3)
Наконец, управление возвращается в среду хоста. Если status равно нулю или EXIT_SUCCESS, возвращается форма статуса, successful terminationопределяемая реализацией. Если status есть EXIT_FAILURE, возвращается форма статуса, unsuccessful terminationопределяемая реализацией. В противном случае возвращаемый статус определяется реализацией.217

int at_quick_exit(c-atexit-handler* f) noexcept; int at_quick_exit(atexit-handler* f) noexcept;

Effects: В at_quick_exit() функции регистрации функции , на которую указывает f называться без аргументов при quick_exit вызове. Не определено , является ли вызов at_quick_exit() делает , что не happen before все вызовы quick_exit будут преуспевать. [ Note: Эти at_quick_exit() функции не вводить гонки данных ([res.on.data.races]). ] [ Порядок регистрации может быть неопределенным, если он был вызван из более чем одного потока. ] [ В регистрации отличается от регистраций и приложениям могут понадобиться вызвать как регистрационные функции с теми же аргументами. ] — end note Note: at_quick_exit — end note Note: at_quick_exit atexit — end note

Implementation limits: Реализация должна поддерживать регистрацию не менее 32 функций.

Returns: Ноль в случае успешной регистрации и ненулевое значение в случае неудачи.

[[noreturn]] void quick_exit(int status) noexcept;

Effects: Функции, зарегистрированные с помощью вызовов at_quick_exit , вызываются в порядке, обратном их регистрации, за исключением того, что функция должна вызываться после любых ранее зарегистрированных функций, которые уже были вызваны во время регистрации. Объекты не должны быть уничтожены в результате вызова quick_exit. Если элемент управления оставляет зарегистрированную функцию, вызванную, quick_exit потому что функция не предоставляет обработчик для возникшего исключения, std::terminate() должна быть вызвана. [ Note: Функция, зарегистрированная через at_quick_exit , вызывается вызывающим потоком quick_exit, который может быть другим потоком, чем тот, который ее зарегистрировал, поэтому зарегистрированные функции не должны полагаться на идентичность объектов с длительностью хранения потока. ] После вызова зарегистрированных функций вызовет . [ Стандартные файловые буферы не сбрасываются. ] — end note quick_exit _Exit(status) Note: — end note

Remarks: Функция quick_exit безопасна для сигналов ([csignal.syn]), если функции, зарегистрированные с помощью at_quick_exit .

Смотрите также: [basic.start], [basic.start.term], ISO C 7.22.4.

215)

Функция вызывается каждый раз, когда она регистрируется.

216)

Все объекты с автоматической продолжительностью хранения уничтожаются в программе, которая не main function содержит автоматических объектов и выполняет вызов exit(). Управление может быть передано напрямую такой main функции, вызвав исключение, которое было перехвачено main.

217)

Макросы EXIT_FAILURE и EXIT_SUCCESS определены в <cstdlib>.

21.6 Dynamic memory management [support.dynamic]

Заголовок <new> определяет несколько функций, которые управляют распределением динамической памяти в программе. Он также определяет компоненты для сообщения об ошибках управления хранилищем.

21.6.1 Header <new> synopsis [new.syn]

namespace std {
  class bad_alloc;
  class bad_array_new_length;
  enum class align_val_t : size_t {};
  struct nothrow_t { explicit nothrow_t() = default; };
  extern const nothrow_t nothrow;
  using new_handler = void (*)();
  new_handler get_new_handler() noexcept;
  new_handler set_new_handler(new_handler new_p) noexcept;

  // [ptr.launder], pointer optimization barrier
  template <class T> constexpr T* launder(T* p) noexcept;

  // [hardware.interference], hardware interference size
  inline constexpr size_t hardware_destructive_interference_size = implementation-defined;
  inline constexpr size_t hardware_constructive_interference_size = implementation-defined;
}

void* operator new(std::size_t size);
void* operator new(std::size_t size, std::align_val_t alignment);
void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
void* operator new(std::size_t size, std::align_val_t alignment,
                   const std::nothrow_t&) noexcept;
void  operator delete(void* ptr) noexcept;
void  operator delete(void* ptr, std::size_t size) noexcept;
void  operator delete(void* ptr, std::align_val_t alignment) noexcept;
void  operator delete(void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
void  operator delete(void* ptr, const std::nothrow_t&) noexcept;
void  operator delete(void* ptr, std::align_val_t alignment,
                      const std::nothrow_t&) noexcept;
void* operator new[](std::size_t size);
void* operator new[](std::size_t size, std::align_val_t alignment);
void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
void* operator new[](std::size_t size, std::align_val_t alignment,
                     const std::nothrow_t&) noexcept;
void  operator delete[](void* ptr) noexcept;
void  operator delete[](void* ptr, std::size_t size) noexcept;
void  operator delete[](void* ptr, std::align_val_t alignment) noexcept;
void  operator delete[](void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
void  operator delete[](void* ptr, const std::nothrow_t&) noexcept;
void  operator delete[](void* ptr, std::align_val_t alignment,
                        const std::nothrow_t&) noexcept;

void* operator new  (std::size_t size, void* ptr) noexcept;
void* operator new[](std::size_t size, void* ptr) noexcept;
void  operator delete  (void* ptr, void*) noexcept;
void  operator delete[](void* ptr, void*) noexcept;

Смотрите также: [intro.memory], [basic.stc.dynamic], [expr.new], [expr.delete], [class.free], [memory].

21.6.2 Storage allocation and deallocation [new.delete]

Если не указано иное, положения [basic.stc.dynamic] применяются к библиотечным версиям operator new и operator delete. Если значение аргумента выравнивания, переданное любой из этих функций, не является допустимым значением выравнивания, поведение не определено.

21.6.2.1 Single-object forms [new.delete.single]

void* operator new(std::size_t size); void* operator new(std::size_t size, std::align_val_t alignment);

Effects: allocation functions Вызывается new-expression выделить size байт памяти. Вторая форма вызывается для типа с новым расширенным выравниванием и выделяет память с указанным выравниванием. Первая форма вызывается иначе и выделяет память, выровненную соответствующим образом, для представления любого объекта такого размера, при условии, что тип объекта не имеет выравнивания «новое-расширенное».

Replaceable: Программа C ++ может определять функции с помощью любой из этих сигнатур функций и тем самым заменять версии по умолчанию, определенные стандартной библиотекой C ++.

Required behavior: Вернуть ненулевой указатель на соответствующим образом выровненный storage ([basic.stc.dynamic]) или выдать исключение. Это требование является обязательным для любых заменяющих версий этих функций.bad_alloc

Default behavior:

(4.1)
Выполняет цикл: внутри цикла функция сначала пытается выделить запрошенную память. Включает ли попытка вызов функций стандартной библиотеки C malloc или aligned_alloc не определена.
(4.2)
Возвращает указатель на выделенное хранилище, если попытка успешна. В противном случае, если current new_handler ([get.new.handler]) является значением нулевого указателя, бросает bad_alloc.
(4.3)
В противном случае функция вызывает текущую new_handler функцию. Если вызванная функция возвращается, цикл повторяется.
(4.4)
Цикл завершается, когда попытка выделить запрошенное хранилище успешна или когда вызываемая new_handler функция не возвращает.

void* operator new(std::size_t size, const std::nothrow_t&) noexcept; void* operator new(std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept;

Effects: То же, что и выше, за исключением того, что они вызываются версией размещения, new-expression когда программа C ++ предпочитает результат нулевого указателя в качестве индикации ошибки, а не bad_alloc исключения.

Required behavior: Верните ненулевой указатель на соответствующим образом выровненный storage ([basic.stc.dynamic]) или верните нулевой указатель. Каждая из этих версий nothrow operator new возвращает указатель, полученный, как если бы он был получен от (возможно, замененной) соответствующей функции без размещения. Это требование является обязательным для любых заменяющих версий этих функций.

Default behavior: Звонки operator new(size), или operator new(size, alignment)соответственно. Если вызов возвращается нормально, возвращает результат этого вызова. В противном случае возвращает нулевой указатель.

[ Example:

T* p1 = new T;                  // throws bad_alloc if it fails
T* p2 = new(nothrow) T;         // returns nullptr if it fails

— end example ]

void operator delete(void* ptr) noexcept; void operator delete(void* ptr, std::size_t size) noexcept; void operator delete(void* ptr, std::align_val_t alignment) noexcept; void operator delete(void* ptr, std::size_t size, std::align_val_t alignment) noexcept;

Effects: Вызывается deallocation functions объектом, delete-expression чтобы сделать значение ptr недопустимым.

Replaceable: Программа C ++ может определять функции с любой из этих сигнатур функций и тем самым заменять версии по умолчанию, определенные стандартной библиотекой C ++. Если функция без size параметра определена, программа также должна определить соответствующую функцию с size параметром. Если функция с size параметром определена, программа также должна определить соответствующую версию без size параметра. [ Note: Приведенное ниже поведение по умолчанию может измениться в будущем, что потребует замены обеих функций освобождения при замене функции распределения. ] — end note

Requires: ptr должен быть нулевым указателем или его значение должно представлять адрес блока памяти, выделенного более ранним вызовом (возможно, замененного) operator new(std::size_t) или operator new(std::size_t, std::align_val_t) который не был аннулирован промежуточным вызовом operator delete.

Requires: Если у реализации есть, strict pointer safety то ptr должен быть безопасный указатель.

Requires: Если alignment параметр отсутствует, ptr функция распределения должна вернуть его без alignment параметра. Если присутствует, alignment аргумент должен быть равен alignment аргументу, переданному возвращенной функции распределения ptr. Если присутствует, size аргумент должен быть равен size аргументу, переданному возвращенной функции распределения ptr.

Required behavior: Вызов объекта operator delete с size параметром может быть изменен на вызов соответствующего объекта operator delete без size параметра, не влияя на выделение памяти. [ Note: Соответствующая реализация предназначена для operator delete(void* ptr, std::size_t size) простого вызова operator delete(ptr). ] — end note

Default behavior: Функции, у которых есть size параметр, передают свои другие параметры соответствующей функции без size параметра. [ Note: См. Примечание в предыдущем Replaceable: абзаце. ] — end note

Default behavior: Если ptr равно нулю, ничего не делает. В противном случае восстанавливает память, выделенную предыдущим вызовом operator new.

Remarks: Это не определенно , при каких условиях части или все такого очищенного хранения будет выделяться при последующих вызовах operator new или любым из aligned_alloc, calloc, mallocили realloc, объявленных в <cstdlib>.

void operator delete(void* ptr, const std::nothrow_t&) noexcept; void operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;

Effects: deallocation functions Называется реализацией для отображения значения ptr инвалида , когда конструктор вызывается из версии размещения nothrow из new-expressionсгенерирует исключение.

Requires: Если у реализации есть, strict pointer safety то ptr должен быть безопасный указатель.

Default behavior: Звонки operator delete(ptr), или operator delete(ptr, alignment)соответственно.

21.6.2.2 Array forms [new.delete.array]

void* operator new[](std::size_t size); void* operator new[](std::size_t size, std::align_val_t alignment);

Effects: allocation functions Называется формой массива new-expression выделить size байты памяти. Вторая форма вызывается для типа с новым расширенным выравниванием и выделяет память с указанным выравниванием. Первая форма вызывается иначе и выделяет память, выровненную соответствующим образом, для представления любого объекта массива такого размера или меньше, при условии, что тип объекта не имеет выравнивания «новое-расширенное».218

Required behavior: То же, что и для соответствующих однообъектных форм. Это требование является обязательным для любых заменяющих версий этих функций.

Default behavior: Возвращает operator new(size), или operator new(size, alignment)соответственно.

void* operator new[](std::size_t size, const std::nothrow_t&) noexcept; void* operator new[](std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept;

Required behavior: Верните ненулевой указатель на соответствующим образом выровненный storage ([basic.stc.dynamic]) или верните нулевой указатель. Каждая из этих версий nothrow operator new[] возвращает указатель, полученный, как если бы он был получен от (возможно, замененной) соответствующей функции без размещения. Это требование является обязательным для любых заменяющих версий этих функций.

Default behavior: Звонки operator new[](size), или operator new[](size, alignment)соответственно. Если вызов возвращается нормально, возвращает результат этого вызова. В противном случае возвращает нулевой указатель.

void operator delete[](void* ptr) noexcept; void operator delete[](void* ptr, std::size_t size) noexcept; void operator delete[](void* ptr, std::align_val_t alignment) noexcept; void operator delete[](void* ptr, std::size_t size, std::align_val_t alignment) noexcept;

Effects: deallocation functions Называется формой массива элементов delete-expression для отображения значения ptr недействительно.

Requires: ptr должен быть нулевым указателем или его значение должно представлять адрес блока памяти, выделенного более ранним вызовом (возможно, замененного) operator new[](std::size_t) или operator new[](std::size_t, std::align_val_t) который не был аннулирован промежуточным вызовом operator delete[].

Requires: Если у реализации есть, strict pointer safety то ptr должен быть безопасный указатель.

Required behavior: Вызов объекта operator delete[] с size параметром может быть изменен на вызов соответствующего объекта operator delete[] без size параметра, не влияя на выделение памяти. [ Note: Соответствующая реализация предназначена для operator delete[](void* ptr, std::size_t size) простого вызова operator delete[](ptr). ] — end note

Default behavior: Функции, у которых есть size параметр, передают свои другие параметры соответствующей функции без size параметра. Функции, не имеющие size параметра, передают свои параметры соответствующей operator delete (однообъектной) функции.

void operator delete[](void* ptr, const std::nothrow_t&) noexcept; void operator delete[](void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;

Effects: deallocation functions Называется реализацией для отображения значения ptr инвалида , когда конструктор вызывается из версии размещения nothrow массива new-expressionсгенерирует исключение.

Requires: ptr должен быть нулевым указателем или его значение должно представлять адрес блока памяти, выделенного более ранним вызовом (возможно, замененного) operator new[](std::size_t) или operator new[](std::size_t, std::align_val_t) который не был аннулирован промежуточным вызовом operator delete[].

Requires: Если у реализации есть, strict pointer safety то ptr должен быть безопасный указатель.

Default behavior: Звонки operator delete[](ptr), или operator delete[](ptr, alignment)соответственно.

218)

Это не является прямой обязанностью operator new[] или operator delete[] записывать количество повторений или размер элемента массива. Эти операции выполняются в другом месте массива new и delete выражений. Однакоnew выражение массива может увеличить size аргумент до, operator new[] чтобы получить место для хранения дополнительной информации.

21.6.2.3 Non-allocating forms [new.delete.placement]

Эти функции зарезервированы; программа на C ++ может не определять функции, заменяющие версии в стандартной библиотеке C ++ ([constraints]). Положения [basic.stc.dynamic] не применяются к этим формам зарезервированного размещения operator new и operator delete.

void* operator new(std::size_t size, void* ptr) noexcept;

Returns: ptr.

Remarks: Умышленно не выполняет никаких других действий.

[ Example: Это может быть полезно для создания объекта по известному адресу:

void* place = operator new(sizeof(Something));
Something* p = new (place) Something();

— end example ]

void* operator new[](std::size_t size, void* ptr) noexcept;

Returns: ptr.

Remarks: Умышленно не выполняет никаких других действий.

void operator delete(void* ptr, void*) noexcept;

Effects: Умышленно не выполняет никаких действий.

Requires: Если у реализации есть, strict pointer safety то ptr должен быть безопасный указатель.

Remarks: Функция по умолчанию new-expressionвызывается, когда любая часть инициализации в размещении, которая вызывает библиотечный оператор размещения без массива new, завершается выдачей исключения ([expr.new]).

void operator delete[](void* ptr, void*) noexcept;

Effects: Умышленно не выполняет никаких действий.

Requires: Если у реализации есть, strict pointer safety то ptr должен быть безопасный указатель.

Remarks: Функция по умолчанию new-expressionвызывается, когда любая часть инициализации в размещении, которая вызывает библиотечный оператор размещения массива new, завершается выдачей исключения ([expr.new]).

21.6.2.4 Data races [new.delete.dataraces]

Для целей определения существования рас данных, библиотек версий operator new, замены пользователей версий глобального operator new, стандартные функции библиотеки C aligned_alloc, callocи malloc, библиотечные версии operator delete, замены пользователя версий operator delete, стандартной библиотечной функции C free, и стандартный C библиотечная функция realloc не должна вводить гонку данных ([res.on.data.races]). Вызов этих функций, которые выделяют или освобождают конкретную единицу памяти, должны происходить в едином общем порядке, и каждый такой вызов освобождения должен выполнять happen before следующее выделение (если таковое имеется) в этом порядке.

21.6.3 Storage allocation errors [alloc.errors]

21.6.3.1 Class bad_alloc [bad.alloc]

namespace std {
  class bad_alloc : public exception {
  public:
    bad_alloc() noexcept;
    bad_alloc(const bad_alloc&) noexcept;
    bad_alloc& operator=(const bad_alloc&) noexcept;
    const char* what() const noexcept override;
  };
}

Класс bad_alloc определяет тип объектов, создаваемых реализацией как исключения, чтобы сообщить об ошибке выделения памяти.

bad_alloc() noexcept;

Effects: Создает объект класса bad_alloc.

bad_alloc(const bad_alloc&) noexcept; bad_alloc& operator=(const bad_alloc&) noexcept;

Effects: Копирует объект класса bad_alloc.

const char* what() const noexcept override;

Returns: An реализации определенных НТБ .

Remarks: Сообщение может быть null-terminated multibyte string, подходящим для преобразования и отображенным как wstring ([string.classes], [locale.codecvt]).

21.6.3.2 Class bad_array_new_length [new.badlength]

namespace std {
  class bad_array_new_length : public bad_alloc {
  public:
    bad_array_new_length() noexcept;
    const char* what() const noexcept override;
  };
}

Класс bad_array_new_length определяет тип объектов, создаваемых реализацией как исключения, чтобы сообщить о попытке выделить массив размером меньше нуля или больше определенного реализацией limit ([expr.new]).

bad_array_new_length() noexcept;

Effects: создает объект класса bad_array_new_length.

const char* what() const noexcept override;

Returns: An реализации определенных НТБ .

21.6.3.3 Type new_handler [new.handler]

using new_handler = void (*)();

Тип a, handler function который будет вызываться operator new() or operator new[]() ([new.delete]), когда они не могут удовлетворить запрос на дополнительное хранилище.

Required behavior: A new_handler должен выполнить одно из следующих действий:

(2.1)
сделать больше памяти доступным для распределения, а затем вернуть;
(2.2)
генерировать исключение типа bad_alloc или класса, производного от bad_alloc;
(2.3)
прекратить выполнение программы, не возвращаясь к вызывающей стороне.

21.6.3.4 set_new_handler [set.new.handler]

new_handler set_new_handler(new_handler new_p) noexcept;

Effects: Устанавливает функцию, обозначенную new_p как текущая new_handler.

Returns: Предыдущий new_handler.

Remarks: Начальный new_handler - это нулевой указатель.

21.6.3.5 get_new_handler [get.new.handler]

new_handler get_new_handler() noexcept;

Returns: Текущий new_handler. [ Note: Это может быть значение нулевого указателя. ] — end note

21.6.4 Pointer optimization barrier [ptr.launder]

template <class T> constexpr T* launder(T* p) noexcept;

Requires: p представляет адрес A байта в памяти. Объект , X который находится в пределах его lifetime и тип которого находится similar в T расположена по адресу A. Все байты памяти, которые будут доступны через результат, доступны через p (см. Ниже).

Returns: Значение типа T * , указывающее на X.

Remarks: Вызов этой функции может использоваться в выражении основной константы всякий раз, когда значение ее аргумента может использоваться в выражении основной константы. Байт хранилища доступен через значение указателя, которое указывает на объект, Y если он находится в памяти, занятой Y, объект, который является взаимопреобразуемым по указателю Y, или объект массива, непосредственно включающий его, если он Y является элементом массива. Программа неправильно сформирована, если T это функция типа или cv void.

[ Note: Если новый объект создается в хранилище, занимаемом существующим объектом того же типа, указатель на исходный объект может использоваться для ссылки на новый объект, если тип не содержит const или не ссылается на члены; в последних случаях эту функцию можно использовать для получения полезного указателя на новый объект. Смотрите [basic.life]. ] — end note

[ Example:

struct X { const int n; };
X *p = new X{3};
const int a = p->n;
new (p) X{5};                       // p does not point to new object ([basic.life]) because X::n is const
const int b = p->n;                 // undefined behavior
const int c = std::launder(p)->n;   // OK

— end example ]

21.6.5 Hardware interference size [hardware.interference]

inline constexpr size_t hardware_destructive_interference_size = implementation-defined;

Это число является минимальным рекомендуемым смещением между двумя объектами, к которым осуществляется одновременный доступ, чтобы избежать дополнительного снижения производительности из-за конкуренции, вызванной реализацией. Должно быть как минимум alignof(max_align_t).

[ Example:

struct keep_apart {
  alignas(hardware_destructive_interference_size) atomic<int> cat;
  alignas(hardware_destructive_interference_size) atomic<int> dog;
};

— end example ]

inline constexpr size_t hardware_constructive_interference_size = implementation-defined;

Это число представляет собой максимальный рекомендуемый размер непрерывной памяти, занятой двумя объектами, доступ к которым осуществляется с временной локальностью для одновременных потоков. Должно быть как минимум alignof(max_align_t).

[ Example:

struct together {
  atomic<int> dog;
  int puppy;
};
struct kennel {
  // Other data members...
  alignas(sizeof(together)) together pack;
  // Other data members...
};
static_assert(sizeof(together) <= hardware_constructive_interference_size);

— end example ]

21.7 Type identification [support.rtti]

Заголовок <typeinfo> определяет тип, связанный с информацией о типе, созданной реализацией. Он также определяет два типа сообщений об ошибках идентификации динамического типа.

21.7.1 Header <typeinfo> synopsis [typeinfo.syn]

namespace std {
  class type_info;
  class bad_cast;
  class bad_typeid;
}

См. Также: [expr.dynamic.cast], [expr.typeid].

21.7.2 Class type_info [type.info]

namespace std {
  class type_info {
  public:
    virtual ~type_info();
    bool operator==(const type_info& rhs) const noexcept;
    bool operator!=(const type_info& rhs) const noexcept;
    bool before(const type_info& rhs) const noexcept;
    size_t hash_code() const noexcept;
    const char* name() const noexcept;

    type_info(const type_info& rhs) = delete;                   // cannot be copied
    type_info& operator=(const type_info& rhs) = delete;        // cannot be copied
  };
}

Класс type_info описывает информацию о типе, созданную реализацией. Объекты этого класса эффективно хранят указатель на имя типа и закодированное значение, подходящее для сравнения двух типов на равенство или порядок сортировки. Имена, правила кодирования и последовательность сортировки для типов не определены и могут отличаться в зависимости от программы.

bool operator==(const type_info& rhs) const noexcept;

Effects: Сравнивает текущий объект с rhs.

Returns: true если два значения описывают один и тот же тип.

bool operator!=(const type_info& rhs) const noexcept;

Returns: !(*this == rhs).

bool before(const type_info& rhs) const noexcept;

Effects: Сравнивает текущий объект с rhs.

Returns: true если *this предшествует rhs в порядке сортировки реализации.

size_t hash_code() const noexcept;

Returns: Неуказанное значение, за исключением того, что в рамках одного выполнения программы оно должно возвращать одно и то же значение для любых двух type_info сравниваемых объектов.

Remarks: Реализация должна возвращать разные значения для двух type_info объектов, которые не равны для сравнения.

const char* name() const noexcept;

Returns: An реализации определенных НТБ .

Remarks: Сообщение может быть форматом null-terminated multibyte string, подходящим для преобразования и отображенным как wstring ([string.classes], [locale.codecvt])

21.7.3 Class bad_cast [bad.cast]

namespace std {
  class bad_cast : public exception {
  public:
    bad_cast() noexcept;
    bad_cast(const bad_cast&) noexcept;
    bad_cast& operator=(const bad_cast&) noexcept;
    const char* what() const noexcept override;
  };
}

Класс bad_cast определяет тип объектов, создаваемых реализацией как исключения для сообщения о выполнении недопустимого dynamic_cast выражения ([expr.dynamic.cast]).

bad_cast() noexcept;

Effects: Создает объект класса bad_cast.

bad_cast(const bad_cast&) noexcept; bad_cast& operator=(const bad_cast&) noexcept;

Effects: Копирует объект класса bad_cast.

const char* what() const noexcept override;

Returns: An реализации определенных НТБ .

21.7.4 Class bad_typeid [bad.typeid]

namespace std {
  class bad_typeid : public exception {
  public:
    bad_typeid() noexcept;
    bad_typeid(const bad_typeid&) noexcept;
    bad_typeid& operator=(const bad_typeid&) noexcept;
    const char* what() const noexcept override;
  };
}

Класс bad_typeid определяет тип объектов, создаваемых реализацией как исключения для сообщения о нулевом указателе в typeid выражении ([expr.typeid]).

bad_typeid() noexcept;

Effects: Создает объект класса bad_typeid.

bad_typeid(const bad_typeid&) noexcept; bad_typeid& operator=(const bad_typeid&) noexcept;

Effects: Копирует объект класса bad_typeid.

const char* what() const noexcept override;

Returns: An реализации определенных НТБ .

21.8 Exception handling [support.exception]

Заголовок <exception> определяет несколько типов и функций, связанных с обработкой исключений в программе C ++.

21.8.1 Header <exception> synopsis [exception.syn]

namespace std {
  class exception;
  class bad_exception;
  class nested_exception;

  using terminate_handler = void (*)();
  terminate_handler get_terminate() noexcept;
  terminate_handler set_terminate(terminate_handler f) noexcept;
  [[noreturn]] void terminate() noexcept;

  int uncaught_exceptions() noexcept;

  using exception_ptr = unspecified;

  exception_ptr current_exception() noexcept;
  [[noreturn]] void rethrow_exception(exception_ptr p);
  template<class E> exception_ptr make_exception_ptr(E e) noexcept;

  template <class T> [[noreturn]] void throw_with_nested(T&& t);
  template <class E> void rethrow_if_nested(const E& e);
}

Смотрите также: [except.special].

21.8.2 Class exception [exception]

namespace std {
  class exception {
  public:
    exception() noexcept;
    exception(const exception&) noexcept;
    exception& operator=(const exception&) noexcept;
    virtual ~exception();
    virtual const char* what() const noexcept;
  };
}

Класс exception определяет базовый класс для типов объектов, создаваемых в качестве исключений компонентами стандартной библиотеки C ++, и определенных выражений для сообщения об ошибках, обнаруженных во время выполнения программы.

Каждый класс стандартной библиотеки T , производный от класса, exception должен иметь общедоступный конструктор копии и общедоступный оператор присваивания копии, которые не завершаются с исключением. Эти функции-члены должны соответствовать следующему постусловию: если два объекта lhs и rhs оба имеют динамический тип T и lhs являются копией rhs, то strcmp(lhs.what(), rhs.what()) должны быть равны 0.

exception() noexcept;

Effects: Создает объект класса exception.

exception(const exception& rhs) noexcept; exception& operator=(const exception& rhs) noexcept;

Effects: Копирует exception объект.

Postconditions: Если *this и rhs оба имеют динамический тип, exception значение выражения strcmp(what(), rhs.what()) должно быть равно 0.

virtual ~exception();

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

virtual const char* what() const noexcept;

Returns: An реализации определенных НТБ .

Remarks: Сообщение может быть null-terminated multibyte string, подходящим для преобразования и отображенным как wstring ([string.classes], [locale.codecvt]). Возвращаемое значение остается действительным до тех пор, пока объект исключения, из которого оно получено, не будет уничтожен или неconst будет вызвана функция, не являющаяся членом объекта исключения.

21.8.3 Class bad_exception [bad.exception]

namespace std {
  class bad_exception : public exception {
  public:
    bad_exception() noexcept;
    bad_exception(const bad_exception&) noexcept;
    bad_exception& operator=(const bad_exception&) noexcept;
    const char* what() const noexcept override;
  };
}

Класс bad_exception определяет тип объекта, на который ссылается exception_ptr возвращаемый из вызова current_exception ([propagation]), когда текущий активный объект исключения не удается скопировать.

bad_exception() noexcept;

Effects: Создает объект класса bad_exception.

bad_exception(const bad_exception&) noexcept; bad_exception& operator=(const bad_exception&) noexcept;

Effects: Копирует объект класса bad_exception.

const char* what() const noexcept override;

Returns: An реализации определенных НТБ .

21.8.4 Abnormal termination [exception.terminate]

21.8.4.1 Type terminate_handler [terminate.handler]

using terminate_handler = void (*)();

Тип объекта handler function , вызываемого при завершении обработки исключения.std::terminate()

Required behavior: A terminate_handler должен прекратить выполнение программы, не возвращаясь к вызывающей стороне.

Default behavior: terminate_handler Вызовы реализации по умолчаниюabort().

21.8.4.2 set_terminate [set.terminate]

terminate_handler set_terminate(terminate_handler f) noexcept;

Effects: Устанавливает функцию, обозначенную f как текущая функция-обработчик для завершения обработки исключения.

Remarks: Не указано, обозначает ли значение нулевого указателя значение по умолчанию terminate_handler.

Returns: Предыдущий terminate_handler.

21.8.4.3 get_terminate [get.terminate]

terminate_handler get_terminate() noexcept;

Returns: Текущий terminate_handler. [ Note: Это может быть значение нулевого указателя. ] — end note

21.8.4.4 terminate [terminate]

[[noreturn]] void terminate() noexcept;

Remarks: Вызывается реализацией, когда от обработки исключений необходимо отказаться по любой из нескольких причин ([except.terminate]). Также может вызываться непосредственно программой.

Effects: Вызывает terminate_handler функцию. Не указано, какая terminate_handler функция будет вызываться, если во время вызова активно исключение set_terminate. В противном случае вызывает текущую terminate_handler функцию. [ Note: В terminate_handler этом контексте значение по умолчанию всегда считается вызываемым обработчиком. ] — end note

21.8.5 uncaught_exceptions [uncaught.exceptions]

int uncaught_exceptions() noexcept;

Returns: Количество uncaught exceptions.

Remarks: Когда uncaught_exceptions() > 0выброс исключения может привести к вызову std::terminate().

21.8.6 Exception propagation [propagation]

using exception_ptr = unspecified;

Тип exception_ptr может использоваться для ссылки на объект исключения.

exception_ptr должны удовлетворять требованиям NullablePointer.

Два ненулевых значения типа exception_ptr эквивалентны и сравниваются как равные тогда и только тогда, когда они относятся к одному и тому же исключению.

Конструктор по умолчанию exception_ptr создает нулевое значение типа.

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

[ Note: Реализация может использовать интеллектуальный указатель с подсчетом ссылок как exception_ptr. ] — end note

В целях определения наличия гонки данных операции с exception_ptr объектами должны обращаться и изменять только exception_ptr сами объекты, а не исключения, на которые они ссылаются. Использование rethrow_exception на exception_ptr объектах, которые ссылаются на один и тот же объект исключения, не должно приводить к гонке за данные. [ Note: Если rethrow_exception повторно генерируется тот же объект исключения (а не копия), одновременный доступ к этому повторно генерированному объекту исключения может привести к гонке данных. Изменения количества exception_ptr объектов, которые ссылаются на конкретное исключение, не приводят к гонке за данные. ] — end note

exception_ptr current_exception() noexcept;

Returns: exception_ptr Объект , который ссылается на currently handled exception или копию текущего перекачиваемого исключения, или нулевой exception_ptr объект , если исключение не обрабатывается. Указанный объект должен оставаться действительным, по крайней мере, пока существует exception_ptr объект, который на него ссылается. Если функции необходимо выделить память и попытка не удалась, она возвращает exception_ptr объект, который ссылается на экземпляр bad_alloc. Не указано, относятся ли возвращаемые значения двух последовательных вызовов к current_exception одному и тому же объекту исключения. [ Note: То есть не указано, current_exception создается ли новая копия каждый раз при ее вызове. ] Если попытка скопировать текущий объект исключения вызывает исключение, функция возвращает объект, который ссылается на сгенерированное исключение или, если это невозможно, на экземпляр . [ Конструктор копирования вызванного исключения также может дать сбой, поэтому реализации разрешено заменять объект, чтобы избежать бесконечной рекурсии. ] — end note exception_ptr bad_exception Note: bad_exception — end note

[[noreturn]] void rethrow_exception(exception_ptr p);

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

Throws: Объект исключения, на который p ссылается.

template<class E> exception_ptr make_exception_ptr(E e) noexcept;

Effects: Создает exception_ptr объект, который ссылается на копию e, как если бы:

try {
  throw e;
} catch(...) {
  return current_exception();
}

[ Note: Эта функция предназначена для удобства и эффективности. ] — end note

21.8.7 nested_exception [except.nested]

namespace std {
  class nested_exception {
  public:
    nested_exception() noexcept;
    nested_exception(const nested_exception&) noexcept = default;
    nested_exception& operator=(const nested_exception&) noexcept = default;
    virtual ~nested_exception() = default;

    // access functions
    [[noreturn]] void rethrow_nested() const;
    exception_ptr nested_ptr() const noexcept;
  };

  template<class T> [[noreturn]] void throw_with_nested(T&& t);
  template <class E> void rethrow_if_nested(const E& e);
}

Класс nested_exception предназначен для использования в качестве миксина посредством множественного наследования. Он фиксирует текущее обрабатываемое исключение и сохраняет его для дальнейшего использования.

[ Note: nested_exception имеет виртуальный деструктор, чтобы сделать его полиморфным классом. Его наличие можно проверить с помощью dynamic_cast. ] — end note

nested_exception() noexcept;

Effects: Конструктор вызывает current_exception() и сохраняет возвращаемое значение.

[[noreturn]] void rethrow_nested() const;

Effects: Если nested_ptr() возвращает нулевой указатель, функция вызывает std::terminate(). В противном случае он генерирует сохраненное исключение, захваченное *this.

exception_ptr nested_ptr() const noexcept;

Returns: Сохраненное исключение, захваченное этим nested_exception объектом.

template <class T> [[noreturn]] void throw_with_nested(T&& t);

Пусть U будет decay_t<T>.

Requires: U будет CopyConstructible.

Throws: Если is_class_v<U> && !is_final_v<U> && !is_base_of_v<nested_exception, U> это true, исключение неопределенного типа , который публично производный от обоего U и nested_exception и построенного std::forward<T>(t), в противном случае std::forward<T>(t).

template <class E> void rethrow_if_nested(const E& e);

Effects: Если E это не полиморфный тип класса, или если nested_exception это недоступный или неоднозначный базовый класс E, эффекта не будет. В противном случае выполняет:

if (auto p = dynamic_cast<const nested_exception*>(addressof(e)))
  p->rethrow_nested();

21.9 Initializer lists [support.initlist]

Заголовок <initializer_list> определяет шаблон класса и несколько вспомогательных функций, связанных с инициализацией списка (см. [dcl.init.list]). Все функции, указанные в этом подпункте, являются signal-safe ([csignal.syn]).

21.9.1 Header <initializer_list> synopsis [initializer_list.syn]

namespace std {
  template<class E> class initializer_list {
  public:
    using value_type      = E;
    using reference       = const E&;
    using const_reference = const E&;
    using size_type       = size_t;

    using iterator        = const E*;
    using const_iterator  = const E*;

    constexpr initializer_list() noexcept;

    constexpr size_t size() const noexcept;     // number of elements
    constexpr const E* begin() const noexcept;  // first element
    constexpr const E* end() const noexcept;    // one past the last element
  };

  // [support.initlist.range], initializer list range access
  template<class E> constexpr const E* begin(initializer_list<E> il) noexcept;
  template<class E> constexpr const E* end(initializer_list<E> il) noexcept;
}

Объект типа initializer_list<E> предоставляет доступ к массиву объектов типа const E. [ Note: Пара указателей или указатель плюс длина были бы очевидными представлениями для initializer_list. initializer_list используется для реализации списков инициализаторов, как указано в [dcl.init.list]. Копирование списка инициализаторов не копирует базовые элементы. ] — end note

Если объявлена явная специализация или частичная специализацияinitializer_list , программа имеет неправильный формат .

21.9.2 Initializer list constructors [support.initlist.cons]

constexpr initializer_list() noexcept;

Effects: Создает пустой initializer_list объект.

Postconditions: size() == 0.

21.9.3 Initializer list access [support.initlist.access]

constexpr const E* begin() const noexcept;

Returns: Указатель на начало массива. Если size() == 0 значения begin() и не end() указаны, но они должны быть идентичными.

constexpr const E* end() const noexcept;

Returns: begin() + size().

constexpr size_t size() const noexcept;

Returns: Количество элементов в массиве.

Complexity: Постоянное время.

21.9.4 Initializer list range access [support.initlist.range]

template<class E> constexpr const E* begin(initializer_list<E> il) noexcept;

Returns: il.begin().

template<class E> constexpr const E* end(initializer_list<E> il) noexcept;

Returns: il.end().

21.10 Other runtime support [support.runtime]

Заголовки <csetjmp> (нелокальные переходы), <csignal> (обработки сигнала), <cstdarg> (переменные аргументы), и <cstdlib> (среда окружение getenv, system), обеспечивают дополнительную совместимость с кодом C.

Вызов функции getenv не должен вызывать гонку данных ([res.on.data.races]) при условии, что ничто не изменяет среду. [ Note: Вызывает функции POSIX setenv и putenv изменяет среду. ] — end note

Вызов setlocale функции может привести к гонке данных с другими вызовами setlocale функции или с вызовами функций, на которые влияет текущий языковой стандарт C. Реализация должна вести себя так, как если бы ни одна из библиотечных функций не locale::global вызывала эту setlocale функцию.

21.10.1 Header <cstdarg> synopsis [cstdarg.syn]

namespace std {
  using va_list = see below;
}

#define va_arg(V, P) see below
#define va_copy(VDST, VSRC) see below
#define va_end(V) see below
#define va_start(V, P) see below

Содержимое заголовка <cstdarg> такое же, как заголовок стандартной библиотеки C <stdarg.h>, со следующими изменениями: Ограничения, которые ISO C накладывает на второй параметр va_start макроса в заголовке <stdarg.h> , в этом международном стандарте другие. Параметр parmN - это крайний правый параметр в списке переменных параметров определения функции (тот, который находится непосредственно перед ...).219 Если параметр parmN представляет собой расширение пакета ([temp.variadic]) или объект, полученный в результате лямбда-захвата ([expr.prim.lambda]), программа имеет неправильный формат , диагностика не требуется. Если параметр parmN имеет ссылочный тип или тип, несовместимый с типом, который возникает при передаче аргумента, для которого нет параметра, поведение не определено.

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

219)

Обратите внимание, что va_start требуется для работы, как указано, даже если унарный operator& перегружен для типа parmN.

21.10.2 Header <csetjmp> synopsis [csetjmp.syn]

namespace std {
  using jmp_buf = see below;
  [[noreturn]] void longjmp(jmp_buf env, int val);
}

#define setjmp(env) see below

Содержимое заголовка <csetjmp> такие же , как заголовок стандартной библиотеки C <setjmp.h>.

В longjmp(jmp_buf jbuf, int val) этом международном стандарте сигнатура функции имеет более ограниченное поведение. setjmp/longjmp Пара вызова имеет неопределенное поведение , если замену setjmp и longjmp путь catch и throw будет вызывать любые нетривиальные деструкторы для любых автоматических объектов.

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

21.10.3 Header <csignal> synopsis [csignal.syn]

namespace std {
  using sig_atomic_t = see below;

  // [support.signal], signal handlers
  extern "C" using signal-handler = void(int);  // exposition only
  signal-handler* signal(int sig, signal-handler* func);

  int raise(int sig);
}

#define SIG_DFL see below
#define SIG_ERR see below
#define SIG_IGN see below
#define SIGABRT see below
#define SIGFPE see below
#define SIGILL see below
#define SIGINT see below
#define SIGSEGV see below
#define SIGTERM see below

Содержимое заголовка <csignal> такие же , как заголовок стандартной библиотеки C <signal.h>.

21.10.4 Signal handlers [support.signal]

Вызов функции signal синхронизируется с любым результирующим вызовом установленного таким образом обработчика сигнала.

A plain lock-free atomic operation - это вызов функции f из Clause [atomics], такой что:

(2.1)
f это функция atomic_is_lock_free(), или
(2.2)
f это функция-член is_lock_free(), или
(2.3)
f - нестатическая функция-член, вызываемая для объекта A, такая, что A.is_lock_free() дает true, или
(2.4)
f является функцией не являющегося членом, и для каждого указателя к атомным аргумента A передается f, atomic_is_lock_free(A) выходы true.

Оценка проводится, signal-safe если она не включает одно из следующего:

(3.1)
вызов любой стандартной библиотечной функции, за исключением простых атомарных операций без блокировки и функций, явно определенных как безопасные для сигналов. [ Note: Это неявно исключает использование new и delete выражения , которые полагаются на библиотеку , предоставленный распределителем памяти. ] — end note
(3.2)
доступ к объекту с длительностью хранения потока;
(3.3)
dynamic_cast выражение;
(3.4)
выброс исключения;
(3.5)
контролировать ввод try-blockили function-try-block;
(3.6)
инициализация переменной со статической продолжительностью хранения, требующей динамической инициализации ([basic.start.dynamic], [stmt.dcl])220; или
(3.7)
ожидает завершения инициализации переменной со статической продолжительностью хранения ([stmt.dcl]).

Вызов обработчика сигнала имеет неопределенное поведение, если он включает оценку, небезопасную для сигнала.

Функция signal безопасна для сигналов, если она вызывается с первым аргументом, равным номеру сигнала, соответствующему сигналу, вызвавшему вызов обработчика.

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

220)

Такая инициализация может произойти, потому что это первая функция odr-use ([basic.def.odr]) этой переменной.

21 Language support library [language.support]

21.1 General [support.general]

21.2 Common definitions [support.types]

21.2.1 Header <cstddef> synopsis [cstddef.syn]

21.2.2 Header <cstdlib> synopsis [cstdlib.syn]

21.2.3 Null pointers [support.types.nullptr]

21.2.4 Sizes, alignments, and offsets [support.types.layout]

21.2.5 byte type operations [support.types.byteops]

21.3 Implementation properties [support.limits]

21.3.1 General [support.limits.general]

21.3.2 Header <limits> synopsis [limits.syn]

21.3.3 Floating-point type properties [fp.style]

21.3.3.1 Type float_­round_­style [round.style]

21.3.3.2 Type float_­denorm_­style [denorm.style]

21.3.4 Class template numeric_­limits [numeric.limits]

21.3.4.1 numeric_­limits members [numeric.limits.members]

21.3.4.2 numeric_­limits specializations [numeric.special]

21.3.5 Header <climits> synopsis [climits.syn]

21.3.6 Header <cfloat> synopsis [cfloat.syn]

21.4 Integer types [cstdint]

21.4.1 Header <cstdint> synopsis [cstdint.syn]

21.5 Start and termination [support.start.term]

21.6 Dynamic memory management [support.dynamic]

21.6.1 Header <new> synopsis [new.syn]

21.6.2 Storage allocation and deallocation [new.delete]

21.6.2.1 Single-object forms [new.delete.single]

21.6.2.2 Array forms [new.delete.array]

21.6.2.3 Non-allocating forms [new.delete.placement]

21.6.2.4 Data races [new.delete.dataraces]

21.6.3 Storage allocation errors [alloc.errors]

21.6.3.1 Class bad_­alloc [bad.alloc]

21.6.3.2 Class bad_­array_­new_­length [new.badlength]

21.6.3.3 Type new_­handler [new.handler]

21.6.3.4 set_­new_­handler [set.new.handler]

21.6.3.5 get_­new_­handler [get.new.handler]

21.6.4 Pointer optimization barrier [ptr.launder]

21.6.5 Hardware interference size [hardware.interference]

21.7 Type identification [support.rtti]

21.7.1 Header <typeinfo> synopsis [typeinfo.syn]

21.7.2 Class type_­info [type.info]

21.7.3 Class bad_­cast [bad.cast]

21.7.4 Class bad_­typeid [bad.typeid]

21.8 Exception handling [support.exception]

21.8.1 Header <exception> synopsis [exception.syn]

21.8.2 Class exception [exception]

21.8.3 Class bad_­exception [bad.exception]

21.8.4 Abnormal termination [exception.terminate]

21.8.4.1 Type terminate_­handler [terminate.handler]

21.8.4.2 set_­terminate [set.terminate]

21.8.4.3 get_­terminate [get.terminate]

21.8.4.4 terminate [terminate]

21.8.5 uncaught_­exceptions [uncaught.exceptions]

21.8.6 Exception propagation [propagation]

21.8.7 nested_­exception [except.nested]

21.9 Initializer lists [support.initlist]

21.9.1 Header <initializer_­list> synopsis [initializer_list.syn]

21.9.2 Initializer list constructors [support.initlist.cons]

21.9.3 Initializer list access [support.initlist.access]

21.9.4 Initializer list range access [support.initlist.range]

21.10 Other runtime support [support.runtime]

21.10.1 Header <cstdarg> synopsis [cstdarg.syn]

21.10.2 Header <csetjmp> synopsis [csetjmp.syn]

21.10.3 Header <csignal> synopsis [csignal.syn]

21.10.4 Signal handlers [support.signal]

21.3.3.1 Type float_round_style [round.style]

21.3.3.2 Type float_denorm_style [denorm.style]

21.3.4 Class template numeric_limits [numeric.limits]

21.3.4.1 numeric_limits members [numeric.limits.members]

21.3.4.2 numeric_limits specializations [numeric.special]

21.6.3.1 Class bad_alloc [bad.alloc]

21.6.3.2 Class bad_array_new_length [new.badlength]

21.6.3.3 Type new_handler [new.handler]

21.6.3.4 set_new_handler [set.new.handler]

21.6.3.5 get_new_handler [get.new.handler]

21.7.2 Class type_info [type.info]

21.7.3 Class bad_cast [bad.cast]

21.7.4 Class bad_typeid [bad.typeid]

21.8.3 Class bad_exception [bad.exception]

21.8.4.1 Type terminate_handler [terminate.handler]

21.8.4.2 set_terminate [set.terminate]

21.8.4.3 get_terminate [get.terminate]

21.8.5 uncaught_exceptions [uncaught.exceptions]

21.8.7 nested_exception [except.nested]

21.9.1 Header <initializer_list> synopsis [initializer_list.syn]