Пространства имён
Варианты
    Действия

      std::scoped_allocator_adaptor<OuterAlloc,InnerAlloc...>::construct

      Материал из cppreference.com
       
      C++
      Поддержка компилятором
      Автономные и размещённые реализации
      Язык
      Стандартная библиотека
      Заголовки стандартной библиотеки
      Требования к именованию
      Макросы тестирования функциональности (C++20)
      Поддержка языка
      Библиотека концептов (C++20)
      Библиотека метапрограммирования (C++11)
      Библиотека диагностики
      Библиотека общих утилит
      Библиотека строк
      Библиотека контейнеров
      Библиотека итераторов
      Библиотека диапазонов (C++20)
      Библиотека алгоритмов
      Библиотека численных данных
      Библиотека ввода/вывода
      Библиотека локализаций
      Регулярные выражения (C++11)
      Атомарные операции (C++11)
      Библиотека поддержки конкуренции (C++11)
      Библиотека файловой системы (C++17)
      Технические спецификации
      Указатель символов
      Внешние библиотеки
       
      Динамическое управление памятью
      no section name
      Ограниченные алгоритмы неинициализированной памяти
      no section name
      Поддержка сбора мусора
      (C++11)(до C++23)
      (C++11)(до C++23)
      (C++11)(до C++23)
      (C++11)(до C++23)
      (C++11)(до C++23)
      (C++11)(до C++23)



      no section name
      (до C++20*)
      (до C++20*)
      (до C++20*)
       
      std::scoped_allocator_adaptor
       
      <tbody> </tbody>
      Определено в заголовочном файле <scoped_allocator>
      template< class T, class... Args > void construct( T* p, Args&&... args );
      		 (1)
      template< class T1, class T2, class... Args1, class... Args2 > void construct( std::pair<T1, T2>* p, std::piecewise_construct_t, std::tuple<Args1...> x, std::tuple<Args2...> y );
      		 (2) (до C++20)
      template< class T1, class T2 > void construct( std::pair<T1, T2>* p );
      		 (3) (до C++20)
      template< class T1, class T2, class U, class V > void construct( std::pair<T1, T2>* p, U&& x, V&& y );
      		 (4) (до C++20)
      template< class T1, class T2, class U, class V > void construct( std::pair<T1, T2>* p, const std::pair<U, V>& xy );
      		 (5) (до C++20)
      template< class T1, class T2, class U, class V > void construct( std::pair<T1, T2>* p, std::pair<U, V>&& xy );
      		 (6) (до C++20)
      template< class T1, class T2, class NonPair > void construct( std::pair<T1, T2>* p, NonPair&& non_pair );
      		 (7) (до C++20)

      Создаёт объект в выделенном, но не инициализированном хранилище, на которое указывает p, используя OuterAllocator и предоставленные аргументы конструктора. Если объект имеет тип, который сам использует аллокаторы, или если это std::pair, InnerAllocator передаётся созданному объекту.

      Сначала извлекает самый внешний аллокатор OUTERMOST вызвав this->outer_allocator(), а затем рекурсивно вызывает функцию-элемент outer_allocator() для результата этого вызова пока не будет достигнут аллокатор, у которого нет такой функции-элемента.

      Определяет OUTERMOST_ALLOC_TRAITS(x) как std::allocator_traits<std::remove_reference_t<decltype(OUTERMOST(x))>>

      1) Создаёт объект заданного типа T с помощью создания с использованием аллокатора в неинициализированной ячейке памяти, указанной p, используя OUTERMOST в качестве аллокатора. После настройки соглашения об использовании аллокатора, ожидаемого конструктором T, вызывает OUTERMOST_ALLOC_TRAITS(*this)::construct.
      Эта перегрузка участвует в разрешении перегрузки, только если U не является специализацией std::pair.
      		(до C++20)
      Эквивалентно
      std::apply( [p, this](auto&&... newargs) { OUTERMOST_ALLOC_TRAITS(*this)::construct( OUTERMOST(*this), p, std::forward<decltype(newargs)>(newargs)...); }, std::uses_allocator_construction_args( inner_allocator(), std::forward<Args>(args)... ) );
      		(начиная с C++20)
      2) Во-первых, если либо T1, либо T2 поддерживает аллокатор, модифицирует кортежи x и y, чтобы включить соответствующий внутренний аллокатор, в результате чего получаются два новых кортежа xprime и yprime в соответствии со следующими тремя правилами:
      2a) если T1 не поддерживает аллокатор

      (std::uses_allocator<T1, inner_allocator_type>::value == false), тогда xprime равно std::tuple<Args1&&...>(std::move(x)). (Также требуется, чтобы std::is_constructible<T1, Args1...>::value == true).

      2b) если T1 поддерживает аллокатор (std::uses_allocator<T1, inner_allocator_type>::value == true), и его конструктор принимает тег аллокатора

      std::is_constructible<T1, std::allocator_arg_t,
      inner_allocator_type&, Args1...>::value == true      ,
      тогда xprime равно
      std::tuple_cat(std::tuple<std::allocator_arg_t, inner_allocator_type&>(
      std::allocator_arg, inner_allocator()
      ),
      std::tuple<Args1&&...>(std::move(x)))

      2c) если T1 поддерживает аллокатор (std::uses_allocator<T1, inner_allocator_type>::value == true), и его конструктор принимает аллокатор в качестве последнего аргумента

      std::is_constructible<T1, Args1..., inner_allocator_type&>::value == true,
      тогда xprime равно
      std::tuple_cat(std::tuple<Args1&&...>(std::move(x)),
      std::tuple<inner_allocator_type&>(inner_allocator()))      .

      Те же правила применяются к T2 и замене y на yprime.
      После создания xprime и yprime создаёт pair p в выделенном хранилище, вызывая

      std::allocator_traits<O>::construct(OUTERMOST,
      p,
      std::piecewise_construct,
      std::move(xprime),
      std::move(yprime));

      3) Эквивалентно

      construct(p, std::piecewise_construct, std::tuple<>(), std::tuple<>()), то есть передаёт внутренний аллокатор типам элементам pair, если они их принимают.

      4) Эквивалентно

      construct(p, std::piecewise_construct, std::forward_as_tuple(std::forward<U>(x)),
      std::forward_as_tuple(std::forward<V>(y)))

      5) Эквивалентно

      construct(p, std::piecewise_construct, std::forward_as_tuple(xy.first),
      std::forward_as_tuple(xy.second))

      6) Эквивалентно

      construct(p, std::piecewise_construct,
      std::forward_as_tuple(std::forward<U>(xy.first)),
      std::forward_as_tuple(std::forward<V>(xy.second)))

      7) Эта перегрузка участвует в разрешении перегрузки, только если задан шаблон функции только для описания

      template<class A, class B>
      void /*выводит-как-pair*/(const std::pair<A, B>&);      ,
      /*выводит-как-pair*/(non_pair) некорректно, если рассматривать его как невычисленный операнд.
      Эквивалентно construct<T1, T2, T1, T2>(p, std::forward<NonPair>(non_pair));.

      		(до C++20)

      Параметры

      p — указатель на выделенное, но не инициализированное хранилище
      args... — аргументы конструктора для передачи конструктору T
      x — аргументы конструктора для передачи конструктору T1
      y — аргументы конструктора для передачи конструктору T2
      xy — pair, два элемента которой являются аргументами конструктора для T1 и T2
      non_pair — не-pair аргумент для преобразования в pair для дальнейшего построения

      Возвращаемое значение

      (нет)

      Примечание

      Эта функция вызывается (через std::allocator_traits) любым объектом с поддержкой аллокатора, например std::vector, которому присвоен std::scoped_allocator_adaptor в качестве используемого аллокатора. Поскольку inner_allocator сам по себе является экземпляром std::scoped_allocator_adaptor, эта функция также будет вызываться, когда объекты с поддержкой аллокатора, созданные с помощью этой функции, начнут создавать свои собственные элементы.

      Отчёты о дефектах

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

      Номер Применён Поведение в стандарте Корректное поведение
      LWG 2975 C++11 первая перегрузка ошибочно используется для создания
      pair в некоторых случаях       		ограничено не принимать pair
      WG не указан C++11 кусочное создание pair может копировать аргументы преобразовано в кортежи ссылок, чтобы избежать
      копирования
      LWG 3525 C++11 никакая перегрузка не могла обрабатывать не-pair типы,
      конвертируемые в pair       		добавлена перегрузка реконструкции

      Смотрите также

      [static]
      		 создаёт объект в выделенном хранилище
      (шаблон функции) [править]
      (до C++20)
      		 создаёт объект в выделенном хранилище
      (public функция-элемент std::allocator) [править]