Namespaces
Variants

std::inplace_vector<T,N>:: inplace_vector

From cppreference.net
C++
Containers library
std::inplace_vector
Member types
Member functions
Non-member functions
constexpr inplace_vector ( ) noexcept ;
(1) (начиная с C++26)
constexpr explicit inplace_vector ( size_type count ) ;
(2) (начиная с C++26)
constexpr inplace_vector ( size_type count, const T & value ) ;
(3) (начиная с C++26)
template < class InputIt >
constexpr inplace_vector ( InputIt first, InputIt last ) ;
(4) (начиная с C++26)
template < container-compatible-range < T > R >
constexpr inplace_vector ( std:: from_range_t , R && rg ) ;
(5) (начиная с C++26)
constexpr inplace_vector ( const inplace_vector & other ) ;
(6) (начиная с C++26)
constexpr inplace_vector ( inplace_vector && other )
noexcept ( N == 0 || std:: is_nothrow_move_constructible_v < T > ) ;
(7) (начиная с C++26)
constexpr inplace_vector ( std:: initializer_list < T > init ) ;
(8) (начиная с C++26)

Создает новый inplace_vector из различных источников данных.

1) Создает пустой inplace_vector , у которого data ( ) == nullptr и size ( ) == 0 .
2) Создает inplace_vector с count элементами, вставленными по умолчанию.
3) Создает inplace_vector с count копиями элементов со значением value .
4) Создает inplace_vector с содержимым диапазона [ first , last ) .
5) Создает inplace_vector с содержимым диапазона rg .
6) A copy constructor . Создает inplace_vector с копией содержимого other .
Конструктор является тривиальным конструктором копирования если N > 0 и std:: is_trivially_copy_constructible_v < T > оба равны true .
7) A move constructor . Создает inplace_vector с содержимым other используя семантику перемещения.
Конструктор является тривиальным конструктором перемещения если N > 0 и std:: is_trivially_move_constructible_v < T > оба имеют значение true .
8) Создает inplace_vector с содержимым списка инициализации init .

Содержание

Параметры

count - размер контейнера
value - значение для инициализации элементов контейнера
first, last - пара итераторов, определяющая исходный диапазон элементов для копирования
rg - диапазон значений для инициализации элементов контейнера
other - другой inplace_vector для использования в качестве источника инициализации элементов контейнера
init - список инициализации для инициализации элементов контейнера
Требования к типам
-
T должен соответствовать требованиям DefaultInsertable для использования перегрузок (2,3).

Сложность

1) Константа.
2,3) Линейно по count .
4) Линейная по std:: distance ( first, last ) .
5) Линейная по std :: ranges:: distance ( rg ) .
6,7) Линейно по размеру other .
8) Линейно по размеру init .

Исключения

2,3) Выбрасывает std::bad_alloc если count > N .
5) Выбрасывает std::bad_alloc если std :: ranges:: size ( rg ) > N .
8) Выбрасывает std::bad_alloc если init. size ( ) > N .

Пример

Запустить этот код 
#include <cassert>
#include <initializer_list>
#include <inplace_vector>
#include <new>
#include <print>
#include <ranges>
int main()
{
    std::inplace_vector<int, 4> v1; // перегрузка (1)
    assert(v1.size() == 0 && v1.capacity() == 4);
    std::inplace_vector<int, 0> v2; // перегрузка (1), N == 0 разрешено
    assert(v2.size() == 0 && v2.capacity() == 0);
    std::inplace_vector<int, 5> v3(3); // перегрузка (2)
    assert(v3.size() == 3 && v3.capacity() == 5);
    std::println("v3 = {}", v3);
    try
    {
        std::inplace_vector<int, 3> v(4); // перегрузка (2), выбрасывает исключение: count > N
    }
    catch(const std::bad_alloc& ex1)
    {
        std::println("ex1.what(): {}", ex1.что());
    }
    std::inplace_vector<int, 5> v4(3, 8); // перегрузка (3)
    assert(v4.size() == 3 && v4.capacity() == 5);
    std::println("v4 = {}", v4);
    try
    {
        std::inplace_vector<int, 3> v(4, 2); // перегрузка (3), выбрасывает исключение: count > N
    }
    catch(const std::bad_alloc& ex2)
    {
        std::println("ex2.what(): {}", ex2.что());
    }
    const auto init = {1, 2, 3};
    std::inplace_vector<int, 4> v5(init.begin(), init.end()); // перегрузка (4)
    assert(v5.size() == 3 && v5.capacity() == 4);
    std::println("v5 = {}", v5);
    std::inplace_vector<int, 4> v6(std::from_range, init); // перегрузка (5)
    assert(v6.size() == 3 && v6.capacity() == 4);
    std::println("v6 = {}", v6);
    std::inplace_vector<int, 4> v7(v6); // перегрузка (6)
    assert(v7.size() == 3 && v7.capacity() == 4);
    std::println("v7 = {}", v7);
    assert(v6.size() == 3);
    std::inplace_vector<int, 4> v8(std::move(v6)); // перегрузка (7)
    // Обратите внимание, что после перемещения v6 остается в допустимом, но неопределенном состоянии.
    assert(v8.size() == 3 && v8.capacity() == 4);
    std::println("v8 = {}", v8);
    std::inplace_vector<int, 4> v9(init); // перегрузка (8)
    assert(v9.size() == 3 && v9.capacity() == 4);
    std::println("v9 = {}", v9);
    try
    {
        std::inplace_vector<int, 2> v(init); // перегрузка (8), выбрасывает исключение: init.size() > N
    }
    catch(const std::bad_alloc& ex3)
    {
        std::println("ex3.what(): {}", ex3.что());
    }
}

Возможный вывод: 

v3 = [0, 0, 0]
ex1.what(): std::bad_alloc
v4 = [42, 42, 42]
ex2.what(): std::bad_alloc
v5 = [1, 2, 3]
v6 = [1, 2, 3]
v7 = [1, 2, 3]
v8 = [1, 2, 3]
v9 = [1, 2, 3]
ex3.what(): std::bad_alloc

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

присваивает значения контейнеру
(публичная функция-член)
[static]
возвращает количество элементов, которое может содержаться в выделенной в данный момент памяти
(публичная статическая функция-член)
прямой доступ к базовому непрерывному хранилищу
(публичная функция-член)
возвращает количество элементов
(публичная функция-член)
(C++17) (C++20)
возвращает размер контейнера или массива
(шаблон функции)
(C++17)
получает указатель на базовый массив
(шаблон функции)