inplace_vector is a dynamically-resizable array with contiguous inplace storage. The elements of typeT are stored and properly aligned within the object itself. The capacity of the internal storage is fixed at compile-time and is equal toN.

The elements are stored contiguously, which means that elements can be accessed not only through iterators or random-accessoperator[], but also using offsets to regular pointers to elements. A pointer to an element of aninplace_vector may be passed to any function that expects a pointer to an element of a C-array.

Theinplace_vector modelsContainer,ReversibleContainer,ContiguousContainer, andSequenceContainer, including most of theoptional sequence container requirements, except that thepush_front,emplace_front,pop_front, andprepend_range member functions are not provided.

For any positiveN,std::inplace_vector<T, N>::iterator andstd::inplace_vector<T, N>::const_iterator meet theConstexprIterator requirements.

The specializationstd::inplace_vector<T,0> isTriviallyCopyable and is empty.std::is_trivially_default_constructible_v<std::inplace_vector<T,0>> is alsotrue.

Any member function ofstd::inplace_vector<T, N> that would cause insertion beyond the capacityN throwsstd::bad_alloc.

The complexity of common operations oninplace_vectors is as follows:

• Random access to an element viaoperator[] orat() – constant:𝓞(1).
• Insertion or removal of an element at the end – constant:𝓞(1).
• Insertion or removal of elements at the end – linear in the number of elements inserted/removed:𝓞(n).
• Insertion or removal of elements in the beginning or in the middle – linear in the number of elements inserted/removed plus the distance to the end of the vector:𝓞(n).

[edit]Iterator invalidation

std::inplace_vector iterator invalidation guarantees differ fromstd::vector:

• moving aninplace_vector invalidates all iterators;
• swapping twoinplace_vectors invalidates all iterators (during swap, the iterator will continue to point to the same array element, and may thus change its value).

The following member functions potentially invalidate iterators:operator=,assign,assign_range,clear,emplace,erase,insert,insert_range,pop_back,resize, andswap.

The following member functions potentially invalidateend iterator only:append_range,emplace_back,push_back,try_append_range,try_emplace_back,try_push_back,unchecked_emplace_back, andunchecked_push_back.

[edit]Template parameters

[edit]Member types

[edit]Member functions

[edit]Non-member functions

[edit]Notes

The number of elements in ainplace_vector may vary dynamically up to a fixed capacity because elements are stored within the object itself similarly tostd::array. However, objects are initialized as they are inserted intoinplace_vector unlike C arrays orstd::array , which must construct all elements on instantiation.

inplace_vector is useful in environments where dynamic memory allocations are undesired.

[edit]Example

#include <algorithm>#include <array>#include <cassert>#include <inplace_vector> int main(){    std::inplace_vector<int,4> v1{0,1,2};assert(v1.max_size()==4);assert(v1.capacity()==4);assert(v1.size()==3);assert(std::ranges::equal(v1,std::array{0,1,2}));assert(v1[0]==0);assert(v1.at(0)==0);assert(v1.front()==0);assert(*v1.begin()==0);assert(v1.back()==2);    v1.push_back(3);assert(v1.back()==3);assert(std::ranges::equal(v1,std::array{0,1,2,3}));    v1.resize(3);assert(std::ranges::equal(v1,std::array{0,1,2}));assert(v1.try_push_back(3)!= nullptr);assert(v1.back()==3);assert(v1.size()==4);assert(v1.try_push_back(13)== nullptr);// no placeassert(v1.back()==3);assert(v1.size()==4);    v1.clear();assert(v1.size()==0);assert(v1.empty());}

[edit]See also

[edit]External links

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Polski
• Português
• Русский
• 中文