Namespaces
Variants

    std::hive<T,Allocator>::operator=

    From cppreference.com
     
    C++
     
    Containers library
     
    std::hive
     
    hive& operator=( const hive& other );
    		(1) (since C++26) 
    hive& operator=( hive&& other ) noexcept(/* see description */);
    		(2) (since C++26) 
    hive& operator=( std::initializer_list<T> ilist );
    		(3) (since C++26)

    Replaces the contents of the container.

    1) All elements in *this are either copy-assigned to, or destroyed. All elements in other are copied into *this. The relative order of copied elements is preserved. current-limits are unchanged.
    2) Each element in *this is either move-assigned to, or destroyed.
    Let EXCEPT be 
    std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
std::allocator_traits<Allocator>::is_always_equal::value
    Let ALLOC be 
    std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
this->get_allocator() == other.get_allocator()
    • If ALLOC is true, current-limits is set to other.current-limits and each element block is moved from other into *this.
      Pointers and references to the elements of other now refer to those same elements but as members of *this.
      Iterators referring to the elements of other will continue to refer to their elements, but they now behave as iterators into *this, not into other.
    • If ALLOC is false, each element in other is moved into *this.
      References, pointers and iterators referring to the elements of other, as well as end() iterator of other, are invalidated.
    After this operator other.empty() is true. The relative order of the elements of *this is the same as that of the elements of other before the call.
    3) Replaces the contents with those identified by initializer list ilist. All existing elements of *this are either assigned to or destroyed.

    Parameters

    other - another hive to use as data source
    ilist - initializer list to use as data source
    Type requirements
    -
    T must meet the requirements of CopyAssignable and CopyInsertable in order to use overloads (1,3).
    -
    T must meet the requirements of MoveAssignable and MoveInsertable in order to use overload (2). (Only if EXCEPT is false).

    Return value

    *this

    Complexity

    1) Linear in the size of *this and other.
    2) Linear in the size of *this. If ALLOC  is false (which means the allocators do not compare equal and do not propagate), also linear in the size of other.
    3) Linear in the size of *this and ilist.

    Exceptions

    1,3) May throw implementation-defined exceptions.
    2)
    noexcept specification:   
    noexcept(/*EXCEPT*/)

    Example

    Run this code
    #include <hive>
#include <initializer_list>
#include <print>
#include <utility>

int main()
{
    std::hive<int> a{1, 2, 3}, b, c;
    std::println("Initially:");
    std::println("a = {}", a);
    std::println("b = {}", b);
    std::println("c = {}", c);

    b = a; // overload (1)
    std::println("Copy assignment copies data from a to b:");
    std::println("a = {}", a);
    std::println("b = {}", b);

    c = std::move(a); // overload (2)
    std::println("Move assignment moves data from a to c, modifying both a and c:");
    std::println("a = {}", a);
    std::println("c = {}", c);

    c = {4, 5, 6, 7}; // overload (3)
    std::println("Assignment of initializer_list to c:");
    std::println("c = {}", c);
}

    Possible output: 

    Initially:
a = [1, 2, 3]
b = []
c = []
Copy assignment copies data from a to b:
a = [1, 2, 3]
b = [1, 2, 3]
Move assignment moves data from a to c, modifying both a and c:
a = []
c = [1, 2, 3]
Assignment of initializer_list to c:
c = [4, 5, 6, 7]

    See also

    		 constructs the hive
    (public member function) [edit]
    		assigns values to the container
    (public member function) [edit]
    		assigns a range of values to the container
    (public member function) [edit]