Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/algorithm/../container/node_handle.html below:

node-handle - cppreference.com

template</* unspecified */>
class /*node-handle*/;

A node handle is an object that accepts ownership of a single element from an associative containers and unordered associative containers. It may be used to transfer that ownership to another container with compatible nodes.

A node handle has two possible states:

• It refers to an element extracted from a container, or
• it is empty .

If a node handle is not empty, then it contains an allocator that is equal to the allocator of the previously extracted container.

For all map containers (std::map, std::multimap, std::unordered_map, and std::unordered_multimap) whose key_type is Key and mapped_type is T, the behavior of operations involving node handles is undefined if a user-defined specialization of std::pair exists for std::pair<Key, T> or std::pair<const Key, T>.

See AssociativeContainer and UnorderedAssociativeContainer for the actual definitions of the non-exposition-only nested types.

typename ator_traits ::template
    rebind_traits<container_node_type >::pointer ptr_

1. ↑ The ownership of the pointed-to container node was already detached from the source container while extracting the element. Even if the lifetime of the source container has ended, the container node and the contained element are still accessible.

constexpr /*node-handle*/() noexcept;

/*node-handle*/( /*node-handle*/&& other ) noexcept;

1) The default constructor initializes the node handle to the empty state.

The move constructor takes ownership of the container element from

.

• ptr_ is initialized with other.ptr_.
• alloc_ is move constructed with other.alloc_.
• Assigns nullptr to other.ptr_.
• Assigns std::nullopt to other.ptr_.

There is no user-provided copy destructor. node-handle is not CopyConstructible.

Besides move construction and move assignment, a non-empty node-handle can only be created by calling the extract member functions of (unordered) associative containers.

/*node-handle*/& operator=( /*node-handle*/&& other );

The move assignment operator replaces state of *this with the state of other using move semantics.

1. If ptr_ != nullptr is true, destroys the element referred to by *this by calling ator_traits ::destroy, then deallocates the storage for the referred element by calling ator_traits ::rebind_traits<container-node-type >::deallocate.
2. Assigns other.ptr_ to ptr_ .
3. If ator_traits ::propagate_on_container_move_assignment is true, move assigns other.alloc_ to alloc_ .
4. Assigns nullptr to other.ptr_ and assigns std::nullopt to other.alloc_.

If the following values are all false, the behavior is undefined:

• ator_traits ::propagate_on_container_move_assignment
• !alloc_
• alloc_ == other.alloc_

*this

Throws nothing.

There is no user-provided copy assignment operator. node-handle is not CopyAssignable.

~/*node-handle*/();

If ptr_ != nullptr is true, destroys the element referred to by *this by calling ator_traits ::destroy, then deallocates the container element by calling ator_traits ::rebind_traits<container-node-type >::deallocate.

Otherwise, does nothing.

bool empty() const noexcept;

Returns true if the node handle is empty, false otherwise.

ptr_ == nullptr

explicit operator bool() const noexcept;

Converts to false if the node handle is empty, true otherwise.

ptr_ != nullptr

allocator_type get_allocator() const;

Returns a copy of the stored allocator.

If empty() is true, the behavior is undefined.

*alloc_

Throws nothing.

value_type& value() const;

Returns a reference to the element referred to by *this.

If empty() is true, the behavior is undefined.

As described above.

Throws nothing.

key_type& key() const;

Returns a non-const reference to the key_type member of the element referred to by *this.

If empty() is true, the behavior is undefined.

As described above.

Throws nothing.

This function makes it possible to modify the key of a node extracted from a map, and then re-insert it into the map, without ever copying or moving the element.

mapped_type& mapped() const;

Returns a reference to the mapped_type member of the element referred to by *this.

If empty() is true, the behavior is undefined.

As described above.

Throws nothing.

void swap( /*node-handle*/& other ) noexcept(/* see below */);

Calls swap(ptr_ , nh.ptr_ ). If any of the following values is true, also calls swap(alloc_ , nh.alloc_ ):

• ator_traits ::propagate_on_container_swap
• !alloc_
• !other.alloc_

If the following values are all false, the behavior is undefined:

• ator_traits ::propagate_on_container_swap
• !alloc_
• !other.alloc_
• alloc_ == other.alloc_

specification:

noexcept(ator_traits::propagate_on_container_swap::value ||
         ator_traits::is_always_equal::value)

friend void swap(/*node-handle*/& lhs, /*node-handle*/& rhs)
    noexcept(noexcept(lhs.swap(rhs)));

Effectively executes x.swap(y).

This function is not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when node-handle is an associated class of the arguments.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4