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

来自cppreference.com
 
C++
 
容器库
 
std::inplace_vector
成员类型
成员函数
非成员函数
 
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。
2) 构造带有 count 个值初始化元素的 inplace_vector。
3) 构造带有 count 个值为 value 的元素副本的 inplace_vector。
4) 构造具有范围 [first, last) 的内容的 inplace_vector。
5) 构造具有范围 rg 的内容的 inplace_vector。
/*container-compatible-range*/ 的定义见 ranges::to。
如果 ranges::size(rg) 是常量表达式且大于 N，则程序非良构。
6) 复制构造函数。构造具有 other 的内容副本的 inplace_vector。
如果 N > 0 和 std::is_trivially_copy_constructible_v<T> 都是 true，那么此构造函数是平凡的。
7) 移动构造函数。使用移动语义构造具有 other 的内容的 inplace_vector。
如果 N > 0 和 std::is_trivially_move_constructible_v<T> 都是 true，那么此构造函数是平凡的。
8) 构造具有初始化器列表 init 的内容的 inplace_vector。

参数

count - 容器的大小
value - 用以初始化容器元素的值
first, last - 要复制的源元素范围的迭代器对
rg - 包含用以初始化容器元素的值的范围
other - 用以初始化容器元素的来源的另一个 inplace_vector
init - 用以初始化容器元素的初始化器列表
类型要求
-
为使用重载 (2,3)， T 必须满足可默认插入 (DefaultInsertable) 。

复杂度

1) 常数。
2,3) 与 count 成线性。
4) 与 std::distance(first, last) 成线性。
5) 与 std::ranges::distance(rg) 成线性。
6,7) 与 other 的大小成线性。
8) 与 init 的大小成线性。

异常

2,3) 当 count > N 时抛出 std::bad_alloc。
4) 当 std::ranges::distance(first, last) > N 时抛出 std::bad_alloc。
5) 当 std::ranges::size(rg) > N 时抛出 std::bad_alloc。
8) 当 init.size() > N 时抛出 std::bad_alloc。

示例

运行此代码
#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.what());
    }
    
    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.what());
    }
    
    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.what());
    }
}

可能的输出： 

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

参阅

 将值赋给容器
(公开成员函数) [编辑]
[静态]
 返回当前存储空间能够容纳的元素数
(公开静态成员函数) [编辑]
直接访问底层连续存储
(公开成员函数) [编辑]
返回元素数
(公开成员函数) [编辑]
(C++17)(C++20)
 返回容器或数组的大小
(函数模板) [编辑]
(C++17)
 获得指向底层数组的指针
(函数模板) [编辑]