Standard library header <functional>
From cppreference.com
This header is part of the function objects library and provides the standard hash function.
Contents |
[edit] Namespaces
placeholders | Defines placeholders for the unbound arguments in a std::bind expression |
Constants |
|
Defined in namespace
std::placeholders |
|
(C++11)
|
placeholders for the unbound arguments in a std::bind expression (constant) |
[edit] Classes
(C++11)
|
wraps callable object of any type with specified function call signature (class template) |
(C++11)
|
creates a function object out of a pointer to a member (function template) |
(C++11)
|
the exception thrown when invoking an empty std::function (class) |
(C++11)
|
indicates that an object is std::bind expression or can be used as one (class template) |
(C++11)
|
indicates that an object is a standard placeholder or can be used as one (class template) |
(C++11)
|
CopyConstructible and CopyAssignable reference wrapper (class template) |
Hashing |
|
(C++11)
|
hash function object (class template) |
template<> struct hash<bool>; template<> struct hash<char>; |
std::hash specializations for built-in types (class template specialization) |
[edit] Functions
(C++11)
|
binds one or more arguments to a function object (function template) |
(C++11)(C++11)
|
creates a std::reference_wrapper with a type deduced from its argument (function template) |
[edit] Function Objects
Arithmetic operations |
|
function object implementing x + y (class template) |
|
function object implementing x - y (class template) |
|
function object implementing x * y (class template) |
|
function object implementing x / y (class template) |
|
function object implementing x % y (class template) |
|
function object implementing -x (class template) |
|
Comparisons |
|
function object implementing x == y (class template) |
|
function object implementing x != y (class template) |
|
function object implementing x > y (class template) |
|
function object implementing x < y (class template) |
|
function object implementing x >= y (class template) |
|
function object implementing x <= y (class template) |
|
Logical operations |
|
function object implementing x && y (class template) |
|
function object implementing x || y (class template) |
|
function object implementing !x (class template) |
|
Bitwise operations |
|
function object implementing x & y (class template) |
|
function object implementing x | y (class template) |
|
function object implementing x ^ y (class template) |
|
Negators |
|
wrapper function object returning the complement of the unary predicate it holds (class template) |
|
wrapper function object returning the complement of the binary predicate it holds (class template) |
|
constructs custom std::unary_negate object (function template) |
|
constructs custom std::binary_negate object (function template) |
[edit] Deprecated in C++11
Base |
|
(until C++17)
|
adaptor-compatible unary function base class (class template) |
(until C++17)
|
adaptor-compatible binary function base class (class template) |
Binders |
|
(until C++17)(until C++17)
|
function object holding a binary function and one of its arguments (class template) |
(until C++17)(until C++17)
|
binds one argument to a binary function (function template) |
Function adaptors |
|
(until C++17)
|
adaptor-compatible wrapper for a pointer to unary function (class template) |
(until C++17)
|
adaptor-compatible wrapper for a pointer to binary function (class template) |
(until C++17)
|
creates an adaptor-compatible function object wrapper from a pointer to function (function template) |
(until C++17)(until C++17)(until C++17)(until C++17)
|
wrapper for a pointer to nullary or unary member function, callable with a pointer to object (class template) |
(until C++17)
|
creates a wrapper from a pointer to member function, callable with a pointer to object (function template) |
(until C++17)(until C++17)(until C++17)(until C++17)
|
wapper for a pointer to nullary or unary member function, callable with a reference to object (class template) |
(until C++17)
|
creates a wrapper from a pointer to member function, callable with a reference to object (function template) |
[edit] Synopsis
namespace std { // base (deprecated): template <class Arg, class Result> struct unary_function; template <class Arg1, class Arg2, class Result> struct binary_function; // reference_wrapper: template <class T> class reference_wrapper; template <class T> reference_wrapper<T> ref(T&) noexcept; template <class T> reference_wrapper<const T> cref(const T&) noexcept; template <class T> void ref(const T&&) = delete; template <class T> void cref(const T&&) = delete; template <class T> reference_wrapper<T> ref(reference_wrapper<T>) noexcept; template <class T> reference_wrapper<const T> cref(reference_wrapper<T>) noexcept; // arithmetic operations: template <class T> struct plus; template <class T> struct minus; template <class T> struct multiplies; template <class T> struct divides; template <class T> struct modulus; template <class T> struct negate; // comparisons: template <class T> struct equal_to; template <class T> struct not_equal_to; template <class T> struct greater; template <class T> struct less; template <class T> struct greater_equal; template <class T> struct less_equal; // logical operations: template <class T> struct logical_and; template <class T> struct logical_or; template <class T> struct logical_not; // bitwise operations: template <class T> struct bit_and; template <class T> struct bit_or; template <class T> struct bit_xor; // negators: template <class Predicate> class unary_negate; template <class Predicate> unary_negate<Predicate> not1(const Predicate&); template <class Predicate> class binary_negate; template <class Predicate> binary_negate<Predicate> not2(const Predicate&); // bind: template<class T> struct is_bind_expression; template<class T> struct is_placeholder; template<class F, class... BoundArgs> /*unspecified*/ bind(F&&, BoundArgs&&...); template<class R, class F, class... BoundArgs> /*unspecified*/ bind(F&&, BoundArgs&&...); namespace placeholders { // M is the implementation-defined number of placeholders extern /*unspecified*/ _1; extern /*unspecified*/ _2; . . . extern /*unspecified*/ _M; } // binders (deprecated): template <class Fn> class binder1st; template <class Fn, class T> binder1st<Fn> bind1st(const Fn&, const T&); template <class Fn> class binder2nd; template <class Fn, class T> binder2nd<Fn> bind2nd(const Fn&, const T&); // adaptors (deprecated): template <class Arg, class Result> class pointer_to_unary_function; template <class Arg, class Result> pointer_to_unary_function<Arg,Result> ptr_fun(Result (*)(Arg)); template <class Arg1, class Arg2, class Result> class pointer_to_binary_function; template <class Arg1, class Arg2, class Result> pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*)(Arg1,Arg2)); // adaptors (deprecated): template<class S, class T> class mem_fun_t; template<class S, class T, class A> class mem_fun1_t; template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)()); template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)); template<class S, class T> class mem_fun_ref_t; template<class S, class T, class A> class mem_fun1_ref_t; template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()); template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A)); template <class S, class T> class const_mem_fun_t; template <class S, class T, class A> class const_mem_fun1_t; template <class S, class T> const_mem_fun_t<S,T> mem_fun(S (T::*f)() const); template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const); template <class S, class T> class const_mem_fun_ref_t; template <class S, class T, class A> class const_mem_fun1_ref_t; template <class S, class T> const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const); template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const); // member function adaptors: template<class R, class T> /*unspecified*/ mem_fn(R T::*); template<class R, class T, class... Args> /*unspecified*/ mem_fn(R (T::*)(Args...)); template<class R, class T, class... Args> /*unspecified*/ mem_fn(R (T::*)(Args...) const); template<class R, class T, class... Args> /*unspecified*/ mem_fn(R (T::*)(Args...) volatile); template<class R, class T, class... Args> /*unspecified*/ mem_fn(R (T::*)(Args...) const volatile); template<class R, class T, class... Args> /*unspecified*/ mem_fn(R (T::*)(Args...) &); template<class R, class T, class... Args> /*unspecified*/ mem_fn(R (T::*)(Args...) const &); template<class R, class T, class... Args> /*unspecified*/ mem_fn(R (T::*)(Args...) volatile &); template<class R, class T, class... Args> /*unspecified*/ mem_fn(R (T::*)(Args...) const volatile &); template<class R, class T, class... Args> /*unspecified*/ mem_fn(R (T::*)(Args...) &&); template<class R, class T, class... Args> /*unspecified*/ mem_fn(R (T::*)(Args...) const &&); template<class R, class T, class... Args> /*unspecified*/ mem_fn(R (T::*)(Args...) volatile &&); template<class R, class T, class... Args> /*unspecified*/ mem_fn(R (T::*)(Args...) const volatile &&); // polymorphic function wrappers: class bad_function_call; template<class> class function; // undefined template<class R, class... ArgTypes> class function<R(ArgTypes...)>; template<class R, class... ArgTypes> void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&); template<class R, class... ArgTypes> bool operator==(const function<R(ArgTypes...)>&, nullptr_t); template<class R, class... ArgTypes> bool operator==(nullptr_t, const function<R(ArgTypes...)>&); template<class R, class... ArgTypes> bool operator!=(const function<R(ArgTypes...)>&, nullptr_t); template<class R, class... ArgTypes> bool operator!=(nullptr_t, const function<R(ArgTypes...)>&); // hash function base template: template <class T> struct hash; // Hash function specializations template <> struct hash<bool>; template <> struct hash<char>; template <> struct hash<signed char>; template <> struct hash<unsigned char>; template <> struct hash<char16_t>; template <> struct hash<char32_t>; template <> struct hash<wchar_t>; template <> struct hash<short>; template <> struct hash<unsigned short>; template <> struct hash<int>; template <> struct hash<unsigned int>; template <> struct hash<long>; template <> struct hash<long long>; template <> struct hash<unsigned long>; template <> struct hash<unsigned long long>; template <> struct hash<float>; template <> struct hash<double>; template <> struct hash<long double>; template<class T> struct hash<T*>; }
[edit] Class std::reference_wrapper
template <class T> class reference_wrapper { public : // types typedef T type; typedef /*Return type of T*/ result_type; // not always defined typedef /*Single argument of T*/ argument_type; // not always defined typedef /*1st argument of T*/ first_argument_type; // not always defined typedef /*2nd argument of T*/ second_argument_type; // not always defined // construct/copy/destroy reference_wrapper(T&) noexcept; reference_wrapper(T&&) = delete; // do not bind to temporary objects reference_wrapper(const reference_wrapper<T>& x) noexcept; // assignment reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept; // access operator T& () const noexcept; T& get() const noexcept; // invocation template <class... ArgTypes> typename result_of<T&(ArgTypes&&...)>::type operator() (ArgTypes&&...) const; };
[edit] Class std::is_bind_expression
template<class T> struct is_bind_expression : integral_constant<bool, /*true
[edit] Class std::bad_function_call
class bad_function_call : public std::exception { public: // constructor: bad_function_call() noexcept; };
[edit] Class std::function
template<class> class function; // undefined template<class R, class... ArgTypes> class function<R(ArgTypes...)> { public: typedef R result_type; typedef T1 argument_type; // iff sizeof...(ArgTypes) == 1 and // the type in ArgTypes is T1 typedef T1 first_argument_type; // iff sizeof...(ArgTypes) == 2 and // ArgTypes contains T1 and T2 typedef T2 second_argument_type;// iff sizeof...(ArgTypes) == 2 and // ArgTypes contains T1 and T2 // construct/copy/destroy: function() noexcept; function(nullptr_t) noexcept; function(const function&); function(function&&); template<class F> function(F); template<class A> function(allocator_arg_t, const A&) noexcept; template<class A> function(allocator_arg_t, const A&, nullptr_t) noexcept; template<class A> function(allocator_arg_t, const A&, const function&); template<class A> function(allocator_arg_t, const A&, function&&); template<class F, class A> function(allocator_arg_t, const A&, F); function& operator=(const function&); function& operator=(function&&); function& operator=(nullptr_t); template<class F> function& operator=(F&&); template<class F> function& operator=(reference_wrapper<F>) noexcept; ~function(); // function modifiers: void swap(function&) noexcept; template<class F, class A> void assign(F&&, const A&); // function capacity: explicit operator bool() const noexcept; // function invocation: R operator()(ArgTypes...) const; // function target access: const std::type_info& target_type() const noexcept; template <typename T> T* target() noexcept; template <typename T> const T* target() const noexcept; };
[edit] See Also
<string> | Specializes std::hash for std::string, std::u16string, std::u32string, std::wstring |
<system_error> | Specializes std::hash for std::error_code |
<bitset> | Specializes std::hash for std::bitset |
<memory> | Specializes std::hash for std::unique_ptr, std::shared_ptr |
<typeindex> | Specializes std::hash for std::type_index |
<vector> | Specializes std::hash for std::vector<bool> |
<thread> | Specializes std::hash for std::thread::id |