std::hive<T,Allocator>::reshape

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

Symbols index

External libraries

 

Containers library

Sequence

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Associative

set

multiset

map

multimap

Unordered associative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptors

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Views

span (C++20)

mdspan (C++23)

Tables

Iterator invalidation

Member function table

Non-member function table

 

std::hive

Member types
Member functions
hive::hive hive::~hive hive::operator= hive::assign hive::assign_range hive::get_allocator      Operations hive::splice hive::unique hive::sort hive::get_iterator Modifiers hive::emplacehive::emplace_hint hive::insert hive::insert_range hive::erase hive::swap hive::clear	Iterators hive::beginhive::cbegin hive::endhive::cend hive::rbeginhive::crbegin hive::rendhive::crend Capacity hive::empty hive::size hive::max_size hive::capacity hive::reserve hive::shrink_to_fit hive::trim_capacity hive::block_capacity_limits hive::block_capacity_default_limits hive::block_capacity_hard_limits hive::is_within_hard_limits hive::reshape
Non-member functions
erase(std::hive)erase_if(std::hive)	swap(std::hive)
Helper classes
hive_limits
Deduction guides

 

void reshape( std::hive_limits block_limits );		(since C++26)

Reallocates elements within each active block that is not within the bounds of block_limits. The elements are moved to new or existing element blocks which are within the bounds.

Deallocates any element blocks not within the bounds of block_limits.

If an exception is thrown during allocation of a new element block, capacity() may be reduced, reallocation may occur, and current-limits may be assigned a value other than block_limits. Otherwise block_limits is assigned to current-limits. If any other exception is thrown the result is unspecified.

This function does not change the size(), but may change the capacity(). If reallocation happens, the order of the elements in *this may change.

Reallocation invalidates all references, pointers, and iterators (including end()) referring to the elements in *this. If no reallocation happens, they remain valid.

Parameters

block_limits	-	new block capacity limits
Type requirements
- T must be MoveInsertable into std::hive. Otherwise, the behavior is undefined.

Exceptions

Any exception thrown during allocation of a new element block (typically std::bad_alloc) and during construction of an element.

Complexity

Linear in the number of element blocks in *this. If reallocation happens, also linear in the number of reallocated elements.

See also

shrink_to_fit	reduces memory usage by freeing unused memory (public member function)
trim_capacity	deallocates reserved blocks and reduces capacity accordingly (public member function)
capacity	returns the number of elements that can be held in currently allocated storage (public member function)
block_capacity_limits	returns current block capacity limits (public member function)