W3cubDocs

/C++

Standard library header <functional>

This header is part of the function objects library and provides the standard hash function.

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)

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>; 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*>;

std::hash specializations for built-in types
(class template specialization)

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)
(C++17)
invokes any Callable object with given arguments
(function template)

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)
(C++14)
function object implementing ~x
(class template)
Negators
(C++17)
Creates a function object that returns the complement of the result of the function object it holds
(function template)
(deprecated)
wrapper function object returning the complement of the unary predicate it holds
(class template)
(deprecated)
wrapper function object returning the complement of the binary predicate it holds
(class template)
(deprecated)
constructs custom std::unary_negate object
(function template)
(deprecated)
constructs custom std::binary_negate object
(function template)
Searchers
(C++17)
standard C++ library search algorithm implementation
(class template)
(C++17)
Boyer-Moore search algorithm implementation
(class template)
(C++17)
Boyer-Moore-Horspool search algorithm implementation
(class template)

Deprecated in C++11 and removed in C++17

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)
wrapper 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)

Synopsis

namespace std {
  // invoke:
  template <class F, class... Args>
  invoke_result_t<F, Args...> invoke(F&& f, Args&&... args);
 
  // 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 = void> struct plus;
  template <class T = void> struct minus;
  template <class T = void> struct multiplies;
  template <class T = void> struct divides;
  template <class T = void> struct modulus;
  template <class T = void> struct negate;
  template <> struct plus<void>;
  template <> struct minus<void>;
  template <> struct multiplies<void>;
  template <> struct divides<void>;
  template <> struct modulus<void>;
  template <> struct negate<void>;
 
  // comparisons:
  template <class T = void> struct equal_to;
  template <class T = void> struct not_equal_to;
  template <class T = void> struct greater;
  template <class T = void> struct less;
  template <class T = void> struct greater_equal;
  template <class T = void> struct less_equal;
  template <> struct equal_to<void>;
  template <> struct not_equal_to<void>;
  template <> struct greater<void>;
  template <> struct less<void>;
  template <> struct greater_equal<void>;
  template <> struct less_equal<void>;
 
  // logical operations:
  template <class T = void> struct logical_and;
  template <class T = void> struct logical_or;
  template <class T = void> struct logical_not;
  template <> struct logical_and<void>;
  template <> struct logical_or<void>;
  template <> struct logical_not<void>;
 
  // bitwise operations:
  template <class T = void> struct bit_and;
  template <class T = void> struct bit_or;
  template <class T = void> struct bit_xor;
  template <class T = void> struct bit_not;
  template <> struct bit_and<void>;
  template <> struct bit_or<void>;
  template <> struct bit_xor<void>;
  template <> struct bit_not<void>;
 
  // function template not_fn:
  template <class F> /*unspecified*/ not_fn(F&& f);
 
  // 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
    /* implementation-defined */ _1;
    /* implementation-defined */ _2;
    ...
    /* implementation-defined */ _M;
  }
 
  // member function adaptors:
  template<class R, class T> /*unspecified*/ mem_fn(R T::*) noexcept;
 
  // 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) noexcept;
  template<class R, class... ArgTypes>
  bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
  template<class R, class... ArgTypes>
  bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
  template<class R, class... ArgTypes>
  bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
 
  // searchers:
  template<class ForwardIterator, class BinaryPredicate = equal_to<>>
  class default_searcher;
  template<class RandomAccessIterator,
           class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
           class BinaryPredicate = equal_to<>>
  class boyer_moore_searcher;
  template<class RandomAccessIterator,
           class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
           class BinaryPredicate = equal_to<>>
  class boyer_moore_horspool_searcher;
  template<class ForwardIterator, class BinaryPredicate = equal_to<>>
  default_searcher<ForwardIterator, BinaryPredicate>
  make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
                        BinaryPredicate pred = BinaryPredicate());
  template<class RandomAccessIterator,
           class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
           class BinaryPredicate = equal_to<>>
  boyer_moore_searcher<RandomAccessIterator, Hash, BinaryPredicate>
  make_boyer_moore_searcher(RandomAccessIterator pat_first,
                            RandomAccessIterator pat_last,
                            Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
  template<class RandomAccessIterator,
           class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
           class BinaryPredicate = equal_to<>>
  boyer_moore_horspool_searcher<RandomAccessIterator, Hash, BinaryPredicate>
  make_boyer_moore_horspool_searcher(RandomAccessIterator pat_first,
                                     RandomAccessIterator pat_last,
                                     Hash hf = Hash(),
                                     BinaryPredicate pred = BinaryPredicate());
 
  // hash function primary template:
  template <class T> struct hash;
 
  // function object binders:
  template <class T> inline constexpr bool is_bind_expression_v
  = is_bind_expression<T>::value;
  template <class T> inline constexpr int is_placeholder_v
  = is_placeholder<T>::value;
}

Class std::reference_wrapper

namespace std {
  template <class T> class reference_wrapper {
    public :
    // types
    using type = T;
    // construct/copy/destroy
    reference_wrapper(T&) noexcept;
    reference_wrapper(T&&) = delete; // do not bind to temporary objects
    reference_wrapper(const reference_wrapper& x) noexcept;
    // assignment
    reference_wrapper& operator=(const reference_wrapper& x) noexcept;
    // access
    operator T& () const noexcept;
    T& get() const noexcept;
    // invocation
    template <class... ArgTypes>
    invoke_result_t<T&, ArgTypes...> operator() (ArgTypes&&...) const;
  };
}

Class std::is_bind_expression

namespace std {
  template<class T> struct is_bind_expression;
}

Class std::is_placeholder

namespace std {
  template<class T> struct is_placeholder;
}

Class std::bad_function_call

class bad_function_call : public std::exception {
public:
    // constructor:
    bad_function_call() noexcept;
};

Class std::function

namespace std {
  template<class> class function; // undefined
  template<class R, class... ArgTypes>
  class function<R(ArgTypes...)> {
    public:
    using result_type = R;
    // construct/copy/destroy:
    function() noexcept;
    function(nullptr_t) noexcept;
    function(const function&);
    function(function&&);
    template<class F> function(F);
    function& operator=(const function&);
    function& operator=(function&&);
    function& operator=(nullptr_t) noexcept;
    template<class F> function& operator=(F&&);
    template<class F> function& operator=(reference_wrapper<F>) noexcept;
    ~function();
    // function modifiers:
    void swap(function&) noexcept;
    // function capacity:
    explicit operator bool() const noexcept;
    // function invocation:
    R operator()(ArgTypes...) const;
    // function target access:
    const type_info& target_type() const noexcept;
    template<class T> T* target() noexcept;
    template<class T> const T* target() const noexcept;
  };
  // Null pointer comparisons:
  template <class R, class... ArgTypes>
  bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
  template <class R, class... ArgTypes>
  bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
  template <class R, class... ArgTypes>
  bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
  template <class R, class... ArgTypes>
  bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
  // specialized algorithms:
  template <class R, class... ArgTypes>
  void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
}

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

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/header/functional