std::unordered_set man page on Scientific

Man page or keyword search:  
man Server   26626 pages
apropos Keyword Search (all sections)
Output format
Scientific logo
[printable version]

std::unordered_set(3)					 std::unordered_set(3)

NAME
       std::unordered_set -

       A standard container composed of unique keys (containing at most one of
       each key value) in which the elements' keys are the elements
       themselves.

SYNOPSIS
       Inherits std::__unordered_set< _Value, _Hash, _Pred, _Alloc >.

   Public Types
       typedef _Base::allocator_type allocator_type
       typedef __detail::_Hashtable_const_iterator< value_type,
	   __constant_iterators, __cache_hash_code > const_iterator
       typedef __detail::_Node_const_iterator< value_type,
	   __constant_iterators, __cache_hash_code > const_local_iterator
       typedef _Allocator::const_pointer const_pointer
       typedef _Allocator::const_reference const_reference
       typedef _Allocator::difference_type difference_type
       typedef _Base::hasher hasher
       typedef __detail::_Hashtable_iterator< value_type,
	   __constant_iterators, __cache_hash_code > iterator
       typedef _Base::key_equal key_equal
       typedef _Key key_type
       typedef __detail::_Node_iterator< value_type, __constant_iterators,
	   __cache_hash_code > local_iterator
       typedef _Allocator::pointer pointer
       typedef _Allocator::reference reference
       typedef _Base::size_type size_type
       typedef _Base::value_type value_type

   Public Member Functions
       void __rehash_policy (const _RehashPolicy &)
       const _RehashPolicy & __rehash_policy () const
       _Value_allocator_type _M_get_Value_allocator () const
       const_local_iterator begin (size_type __n) const
       local_iterator begin (size_type __n)
       const_iterator begin () const
       iterator begin ()
       size_type bucket (const key_type &__k) const
       size_type bucket_count () const
       size_type bucket_size (size_type __n) const
       const_local_iterator cbegin (size_type __n) const
       const_iterator cbegin () const
       const_local_iterator cend (size_type) const
       const_iterator cend () const
       void clear ()
       size_type count (const key_type &__k) const
       bool empty () const
       const_local_iterator end (size_type) const
       local_iterator end (size_type)
       const_iterator end () const
       iterator end ()
       std::pair< const_iterator, const_iterator > equal_range (const key_type
	   &__k) const
       std::pair< iterator, iterator > equal_range (const key_type &__k)
       const_iterator erase (const_iterator, const_iterator)
       iterator erase (iterator, iterator)
       size_type erase (const key_type &)
       const_iterator erase (const_iterator)
       iterator erase (iterator)
       const_iterator find (const key_type &__k) const
       iterator find (const key_type &__k)
       allocator_type get_allocator () const
       void insert (initializer_list< value_type > __l)
       template<typename _InputIterator > void insert (_InputIterator __first,
	   _InputIterator __last)
       const_iterator insert (const_iterator, const value_type &__v)
       iterator insert (iterator, const value_type &__v)
       _Insert_Return_Type insert (const value_type &__v)
       key_equal key_eq () const
       float load_factor () const
       size_type max_bucket_count () const
       size_type max_size () const
       unordered_set & operator= (initializer_list< value_type > __l)
       unordered_set & operator= (unordered_set &&__x)
       void rehash (size_type __n)
       size_type size () const
       void swap (_Hashtable &&)
       unordered_set (initializer_list< value_type > __l, size_type __n=10,
	   const hasher &__hf=hasher(), const key_equal &__eql=key_equal(),
	   const allocator_type &__a=allocator_type())
       unordered_set (unordered_set &&__x)
       template<typename _InputIterator > unordered_set (_InputIterator __f,
	   _InputIterator __l, size_type __n=10, const hasher &__hf=hasher(),
	   const key_equal &__eql=key_equal(), const allocator_type
	   &__a=allocator_type())
       unordered_set (size_type __n=10, const hasher &__hf=hasher(), const
	   key_equal &__eql=key_equal(), const allocator_type
	   &__a=allocator_type())

   Friends
       struct __detail::_Map_base

Detailed Description
   template<class _Value, class _Hash = hash<_Value>, class _Pred =
       std::equal_to<_Value>, class _Alloc = std::allocator<_Value>> class
       std::unordered_set< _Value, _Hash, _Pred, _Alloc >
       A standard container composed of unique keys (containing at most one of
       each key value) in which the elements' keys are the elements
       themselves.

       Meets the requirements of a container, and unordered associative
       container

       Parameters:
	   Value Type of key objects.
	   Hash Hashing function object type, defaults to hash<Value>.
	   Pred Predicate function object type, defaults to equal_to<Value>.
	   Alloc Allocator type, defaults to allocator<Key>.

       Definition at line 181 of file tr1_impl/unordered_set.

Author
       Generated automatically by Doxygen for libstdc++ from the source code.

libstdc++			  22 Nov 2013		 std::unordered_set(3)
[top]

List of man pages available for Scientific

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net