Namespaces
Variants

Standard library header <functional>

From cppreference.net
C++
Standard library headers

이 헤더는 function objects 라이브러리의 일부이며 표준 hash function 을 제공합니다.

목차

네임스페이스

placeholders (C++11) std::bind 표현식에서 바인딩되지 않은 인수들을 위한 플레이스홀더를 제공합니다

클래스

래퍼
(C++11)
복사 생성 가능한 모든 호출 가능 객체의 복사 가능 래퍼
(클래스 템플릿)
(C++23)
주어진 호출 시그니처에서 한정자를 지원하는 모든 호출 가능 객체의 이동 전용 래퍼
(클래스 템플릿)
(C++26)
주어진 호출 시그니처에서 한정자를 지원하는 모든 복사 생성 가능 호출 가능 객체의 복사 가능 래퍼
(클래스 템플릿)
(C++26)
모든 호출 가능 객체의 비소유 래퍼
(클래스 템플릿)
(C++11)
멤버 포인터로부터 함수 객체를 생성함
(함수 템플릿)
(C++11)
CopyConstructible 및 CopyAssignable 참조 래퍼
(클래스 템플릿)
(C++20) (C++20)
std::reference_wrapper 에 감싸진 참조 타입을 얻음
(클래스 템플릿)
헬퍼 클래스
(C++11)
빈 std::function 을 호출할 때 발생하는 예외
(클래스)
(C++11)
객체가 std::bind 표현식이거나 하나로 사용될 수 있음을 나타냅니다
(클래스 템플릿)
(C++11)
객체가 표준 플레이스홀더이거나 플레이스홀더로 사용될 수 있음을 나타냄
(클래스 템플릿)
산술 연산
x + y 연산을 구현하는 함수 객체
(클래스 템플릿)
x - y 를 구현하는 함수 객체
(클래스 템플릿)
x * y 를 구현하는 함수 객체
(클래스 템플릿)
x / y 를 구현하는 함수 객체
(클래스 템플릿)
x % y 를 구현하는 함수 객체
(클래스 템플릿)
- x 를 구현하는 함수 객체
(클래스 템플릿)
비교
x == y 를 구현하는 함수 객체
(클래스 템플릿)
함수 객체 구현: x ! = y
(클래스 템플릿)
x > y 를 구현하는 함수 객체
(클래스 템플릿)
함수 객체 구현 x < y
(클래스 템플릿)
x >= y 를 구현하는 함수 객체
(클래스 템플릿)
함수 객체 구현 x <= y
(클래스 템플릿)
개념 제한 비교
(C++20)
제약된 함수 객체로 x == y 를 구현함
(클래스)
(C++20)
제약된 함수 객체로 x ! = y 를 구현함
(클래스)
(C++20)
제약된 함수 객체로 x > y 를 구현함
(클래스)
(C++20)
x < y 연산을 구현하는 제약된 함수 객체
(클래스)
(C++20)
제약된 함수 객체로 x >= y 를 구현함
(클래스)
(C++20)
x <= y 를 구현하는 제약된 함수 객체
(클래스)
(C++20)
x <=> y 를 구현하는 제약된 함수 객체
(클래스)
논리 연산
x && y를 구현하는 함수 객체
(클래스 템플릿)
x || y 를 구현하는 함수 객체
(클래스 템플릿)
! x 를 구현하는 함수 객체
(클래스 템플릿)
비트 연산
x & y 를 구현하는 함수 객체
(클래스 템플릿)
x | y 를 구현하는 함수 객체
(클래스 템플릿)
함수 객체 구현 x ^ y
(클래스 템플릿)
(C++14)
~x 를 구현하는 함수 객체
(클래스 템플릿)
부정자(Negators)
(C++17)
보유한 함수 객체의 결과값의 보수를 반환하는 함수 객체를 생성합니다
(함수 템플릿)
항등식
(C++20)
인수를 변경 없이 반환하는 함수 객체
(클래스)
검색기
(C++17)
표준 C++ 라이브러리 검색 알고리즘 구현
(클래스 템플릿)
(C++17)
Boyer-Moore 검색 알고리즘 구현
(클래스 템플릿)
(C++17)
Boyer-Moore-Horspool 검색 알고리즘 구현
(클래스 템플릿)
해싱
(C++11)
해시 함수 객체
(클래스 템플릿)
(C++11)
std::hash 기본형, 열거형 및 포인터 타입에 대한 std::hash 특수화
(클래스 템플릿 특수화)

상수

정의된 네임스페이스 std::placeholders
(C++11)
std::bind 표현식에서 바인딩되지 않은 인자들을 위한 플레이스홀더
(상수)

함수

(C++20) (C++23)
함수 객체에 가변 개수의 인수를 순서대로 바인딩합니다
(함수 템플릿)
(C++11)
하나 이상의 인수를 함수 객체에 바인딩합니다
(함수 템플릿)
(C++11) (C++11)
인수의 타입에서 추론된 std::reference_wrapper 를 생성합니다
(함수 템플릿)
(C++17) (C++23)
주어진 인수로 임의의 Callable 객체를 호출 및 반환 타입 지정 가능 (C++23부터)
(함수 템플릿)

C++11에서 사용 중단되고 C++17에서 제거됨

기본(Base)
(C++11에서 사용 중단됨) (C++17에서 제거됨)
어댑터 호환 단항 함수 기본 클래스
(클래스 템플릿)
(C++11에서 사용 중단됨) (C++17에서 제거됨)
어댑터 호환 이항 함수 기본 클래스
(클래스 템플릿)
바인더(Binders)
(C++11에서 사용 중단됨) (C++17에서 제거됨)
이항 함수와 그 인수 하나를 보유하는 함수 객체
(클래스 템플릿)
(C++11에서 사용 중단됨) (C++17에서 제거됨)
이항 함수에 하나의 인수를 바인딩함
(함수 템플릿)
함수 어댑터(Function adaptors)
(C++11에서 사용 중단됨) (C++17에서 제거됨)
단항 함수 포인터용 어댑터 호환 래퍼
(클래스 템플릿)
(C++11에서 사용 중단됨) (C++17에서 제거됨)
이항 함수 포인터용 어댑터 호환 래퍼
(클래스 템플릿)
(C++11에서 사용 중단됨) (C++17에서 제거됨)
함수 포인터로부터 어댑터 호환 함수 객체 래퍼를 생성함
(함수 템플릿)
(C++11에서 사용 중단됨) (C++17에서 제거됨)
객체 포인터로 호출 가능한, 0항 또는 단항 멤버 함수 포인터용 래퍼
(클래스 템플릿)
(C++11에서 사용 중단됨) (C++17에서 제거됨)
객체 포인터로 호출 가능한 멤버 함수 포인터로부터 래퍼를 생성함
(함수 템플릿)
(C++11에서 사용 중단됨) (C++17에서 제거됨)
객체 참조로 호출 가능한, 0항 또는 단항 멤버 함수 포인터용 래퍼
(클래스 템플릿)
(C++11에서 사용 중단됨) (C++17에서 제거됨)
객체 참조로 호출 가능한 멤버 함수 포인터로부터 래퍼를 생성함
(함수 템플릿)

C++17에서 사용 중단되고 C++20에서 제거됨

부정 연산자
(C++17에서 사용 중단됨) (C++20에서 제거됨)
보유한 단항 술어의 보수를 반환하는 래퍼 함수 객체
(클래스 템플릿)
(C++17에서 사용 중단됨) (C++20에서 제거됨)
보유한 이항 술어의 보수를 반환하는 래퍼 함수 객체
(클래스 템플릿)
(C++17에서 사용 중단됨) (C++20에서 제거됨)
사용자 정의 std::unary_negate 객체를 생성함
(함수 템플릿)
(C++17에서 사용 중단됨) (C++20에서 제거됨)
사용자 정의 std::binary_negate 객체를 생성함
(함수 템플릿)

시놉시스 

namespace std {
  // 호출
  template<class F, class... Args>
    constexpr invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)
      noexcept(is_nothrow_invocable_v<F, Args...>);
  template<class R, class F, class... Args>
    constexpr R invoke_r(F&& f, Args&&... args)
      noexcept(is_nothrow_invocable_r_v<R, F, Args...>);
  // reference_wrapper
  template<class T> class reference_wrapper;
  template<class T> constexpr reference_wrapper<T> ref(T&) noexcept;
  template<class T> constexpr 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>
    constexpr reference_wrapper<T> ref(reference_wrapper<T>) noexcept;
  template<class T>
    constexpr reference_wrapper<const T> cref(reference_wrapper<T>) noexcept;
  template<class T> struct unwrap_reference;
  template<class T> using unwrap_reference_t = typename unwrap_reference<T>::type;
  template<class T> struct unwrap_ref_decay;
  template<class T> using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type;
  // common_reference 관련 특수화
  template<class R, class T, template<class> class RQual, template<class> class TQual>
    requires /* 아래 참조 */
  struct basic_common_reference<R, T, RQual, TQual>;
  template<class T, class R, template<class> class TQual, template<class> class RQual>
    requires /* 아래 참조 */
  struct basic_common_reference<T, R, TQual, RQual>;
  // 산술 연산
  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>;
  // 비교
  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>;
  // 논리 연산
  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>;
  // 비트 연산
  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>;
  // identity
  struct identity;
  // function template not_fn
  template<class F> constexpr /* 지정되지 않음 */ not_fn(F&& f);
  // 함수 템플릿 bind_front 및 bind_back
  template<class F, class... Args> constexpr /* 미지정 */ bind_front(F&&, Args&&...);
  template<class F, class... Args> constexpr /* 미지정 */ bind_back(F&&, Args&&...);
  // bind
  template<class T> struct is_bind_expression;
  template<class T>
    inline constexpr bool is_bind_expression_v = is_bind_expression<T>::value;
  template<class T> struct is_placeholder;
  template<class T>
    inline constexpr int is_placeholder_v = is_placeholder<T>::value;
  template<class F, class... BoundArgs>
    constexpr /* 미지정 */ bind(F&&, BoundArgs&&...);
  template<class R, class F, class... BoundArgs>
    constexpr /* 미지정 */ bind(F&&, BoundArgs&&...);
  namespace placeholders {
    // M은 구현에서 정의된 플레이스홀더의 개수입니다
    /* 설명 참조 */ _1;
    /* 설명 참조 */ _2;
               .
               .
               .
    /* 설명 참조 */ _M;
  }
  // 멤버 함수 어댑터
  template<class R, class T>
    constexpr /* 미지정 */ mem_fn(R T::*) noexcept;
  // 다형성 함수 래퍼
  class bad_function_call;
  template<class> class function; // 정의되지 않음
  template<class R, class... ArgTypes> class function<R(ArgTypes...)>;
  template<class R, class... ArgTypes>
    void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
  template<class R, class... ArgTypes>
    bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
  // 이동 전용 래퍼
  template<class...> class move_only_function; // 정의되지 않음
  template<class R, class... ArgTypes>
    class move_only_function<R(ArgTypes...) /*cv ref*/ noexcept(/*noex*/)>;
  // 복사 가능한 래퍼
  template<class...> class copyable_function; // 정의되지 않음
  template<class R, class... ArgTypes>
    class copyable_function<R(ArgTypes...) /*cv ref*/ noexcept(/*noex*/)>;
  // 비소유 래퍼
  template<class...> class function_ref; // 정의되지 않음
  template<class R, class... ArgTypes>
    class function_ref<R(ArgTypes...) /*cv*/ noexcept(/*noex*/)>;
  // 검색자
  template<class ForwardIter, class BinaryPredicate = equal_to<>>
    class default_searcher;
  template<class RandomAccessIter,
           class Hash = hash<typename iterator_traits<RandomAccessIter>::value_type>,
           class BinaryPredicate = equal_to<>>
    class boyer_moore_searcher;
  template<class RandomAccessIter,
           class Hash = hash<typename iterator_traits<RandomAccessIter>::value_type>,
           class BinaryPredicate = equal_to<>>
    class boyer_moore_horspool_searcher;
  // 해시 함수 기본 템플릿
  template<class T>
    struct hash;
  // 개념 제약 비교 연산자
  struct compare_three_way;
  namespace ranges {
    struct equal_to;
    struct not_equal_to;
    struct greater;
    struct less;
    struct greater_equal;
    struct less_equal;
  }
  // 설명 전용
  template<class Fn, class... Args>
    concept /*호출 가능*/ =
      requires (Fn&& fn, Args&&... args) {
        std::forward<Fn>(fn)(std::forward<Args>(args)...);
      };
  // 설명 전용
  template<class Fn, class... Args>
    concept /*nothrow-callable*/ =
      /*호출 가능*/<Fn, Args...> &&
      requires (Fn&& fn, Args&&... args) {
        { std::forward<Fn>(fn)(std::forward<Args>(args)...) } noexcept;
      };
  // 설명 전용
  template<class Fn, class... Args>
    using /*call-result-t*/ = decltype(std::declval<Fn>()(std::declval<Args>()...));
  // 설명 전용
  template<const auto& T>
    using /*decayed-typeof*/ = decltype(auto(T));
}

클래스 템플릿 std::reference_wrapper 

namespace std {
  template<class T> class reference_wrapper {
  public:
    // 타입
    using type = T;
    // 생성/복사/소멸
    template<class U>
      constexpr reference_wrapper(U&&) noexcept(/* 아래 참조 */);
    constexpr reference_wrapper(const reference_wrapper& x) noexcept;
    // 할당
    constexpr reference_wrapper& operator=(const reference_wrapper& x) noexcept;
    // 접근
    constexpr operator T& () const noexcept;
    constexpr T& get() const noexcept;
    // 호출
    template<class... ArgTypes>
      constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...) const
        noexcept(is_nothrow_invocable_v<T&, ArgTypes...>);
    // 비교
    friend constexpr bool operator==(reference_wrapper, reference_wrapper);
    friend constexpr bool operator==(reference_wrapper, const T&);
    friend constexpr bool operator==(reference_wrapper, reference_wrapper<const T>);
    friend constexpr auto operator<=>(reference_wrapper, reference_wrapper);
    friend constexpr auto operator<=>(reference_wrapper, const T&);
    friend constexpr auto operator<=>(reference_wrapper, reference_wrapper<const T>);
  };
  // 추론 가이드
  template<class T>
    reference_wrapper(T&) -> reference_wrapper<T>;
}

클래스 템플릿 std::unwrap_reference 

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

클래스 템플릿 std::unwrap_ref_decay 

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

클래스 템플릿 std::plus 

namespace std {
  template<class T = void> struct plus {
    constexpr T operator()(const T& x, const T& y) const;
  };
  template<> struct plus<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) + std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::minus 

namespace std {
  template<class T = void> struct minus {
    constexpr T operator()(const T& x, const T& y) const;
  };
  template<> struct minus<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) - std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::multiplies 

namespace std {
  template<class T = void> struct multiplies {
    constexpr T operator()(const T& x, const T& y) const;
  };
  template<> struct multiplies<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) * std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::divides 

namespace std {
  template<class T = void> struct divides {
    constexpr T operator()(const T& x, const T& y) const;
  };
  template<> struct divides<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) / std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::modulus 

namespace std {
  template<class T = void> struct modulus {
    constexpr T operator()(const T& x, const T& y) const;
  };
  template<> struct modulus<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) % std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::negate 

namespace std {
  template<class T = void> struct negate {
    constexpr T operator()(const T& x) const;
  };
  template<> struct negate<void> {
    template<class T> constexpr auto operator()(T&& t) const
      -> decltype(-std::forward<T>(t));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::equal_to 

namespace std {
  template<class T = void> struct equal_to {
    constexpr bool operator()(const T& x, const T& y) const;
  };
  template<> struct equal_to<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) == std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::not_equal_to 

namespace std {
  template<class T = void> struct not_equal_to {
    constexpr bool operator()(const T& x, const T& y) const;
  };
  template<> struct not_equal_to<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) != std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::greater 

namespace std {
  template<class T = void> struct greater {
    constexpr bool operator()(const T& x, const T& y) const;
  };
  template<> struct greater<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) > std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::less 

namespace std {
  template<class T = void> struct less {
    constexpr bool operator()(const T& x, const T& y) const;
  };
  template<> struct less<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) < std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::greater_equal 

namespace std {
  template<class T = void> struct greater_equal {
    constexpr bool operator()(const T& x, const T& y) const;
  };
  template<> struct greater_equal<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) >= std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::less_equal 

namespace std {
  template<class T = void> struct less_equal {
    constexpr bool operator()(const T& x, const T& y) const;
  };
  template<> struct less_equal<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) <= std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 std::compare_three_way 

namespace std {
  struct compare_three_way {
    template<class T, class U>
    constexpr auto operator()(T&& t, U&& u) const;
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 std::ranges::equal_to 

namespace std::ranges {
  struct equal_to {
    template<class T, class U>
    constexpr bool operator()(T&& t, U&& u) const;
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 std::ranges::not_equal_to 

namespace std::ranges {
  struct not_equal_to {
    template<class T, class U>
    constexpr bool operator()(T&& t, U&& u) const;
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 std::ranges::greater 

namespace std::ranges {
  struct greater {
    template<class T, class U>
    constexpr bool operator()(T&& t, U&& u) const;
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 std::ranges::less 

namespace std::ranges {
  struct less {
    template<class T, class U>
    constexpr bool operator()(T&& t, U&& u) const;
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 std::ranges::greater_equal 

namespace std::ranges {
  struct greater_equal {
    template<class T, class U>
    constexpr bool operator()(T&& t, U&& u) const;
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 std::ranges::less_equal 

namespace std::ranges {
  struct less_equal {
    template<class T, class U>
    constexpr bool operator()(T&& t, U&& u) const;
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::logical_and 

namespace std {
  template<class T = void> struct logical_and {
    constexpr bool operator()(const T& x, const T& y) const;
  };
  template<> struct logical_and<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) && std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::logical_or 

namespace std {
  template<class T = void> struct logical_or {
    constexpr bool operator()(const T& x, const T& y) const;
  };
  template<> struct logical_or<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) || std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::logical_not 

namespace std {
  template<class T = void> struct logical_not {
    constexpr bool operator()(const T& x) const;
  };
  template<> struct logical_not<void> {
    template<class T> constexpr auto operator()(T&& t) const
      -> decltype(!std::forward<T>(t));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::bit_and 

namespace std {
  template<class T = void> struct bit_and {
    constexpr T operator()(const T& x, const T& y) const;
  };
  template<> struct bit_and<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) & std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::bit_or 

namespace std {
  template<class T = void> struct bit_or {
    constexpr T operator()(const T& x, const T& y) const;
  };
  template<> struct bit_or<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) | std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::bit_xor 

namespace std {
  template<class T = void> struct bit_xor {
    constexpr T operator()(const T& x, const T& y) const;
  };
  template<> struct bit_xor<void> {
    template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
      -> decltype(std::forward<T>(t) ^ std::forward<U>(u));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::bit_not 

namespace std {
  template<class T = void> struct bit_not {
    constexpr T operator()(const T& x) const;
  };
  template<> struct bit_not<void> {
    template<class T> constexpr auto operator()(T&& t) const
      -> decltype(~std::forward<T>(t));
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::identity 

namespace std {
  struct identity {
    template<class T>
      constexpr T&& operator()(T&& t) const noexcept;
    using is_transparent = /* 지정되지 않음 */;
  };
}

클래스 템플릿 std::is_bind_expression 

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

클래스 템플릿 std::is_placeholder 

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

클래스 std::bad_function_call 

namespace std {
  class bad_function_call : public exception {
  public:
    // 특수 멤버 함수의 명세는 [exception] 참조
    const char* what() const noexcept override;
  };
}

클래스 템플릿 std::function 

namespace std {
  template<class> class function; // 정의되지 않음
  template<class R, class... ArgTypes>
  class function<R(ArgTypes...)> {
  public:
    using result_type = R;
    // 생성/복사/소멸
    function() noexcept;
    function(nullptr_t) noexcept;
    function(const function&);
    function(function&&) noexcept;
    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();
    // 함수 수정자
    void swap(function&) noexcept;
    // 함수 용량
    explicit operator bool() const noexcept;
    // 함수 호출
    R operator()(ArgTypes...) const;
    // 함수 대상 접근
    const type_info& target_type() const noexcept;
    template<class T>       T* target() noexcept;
    template<class T> const T* target() const noexcept;
  };
  template<class R, class... ArgTypes>
    function(R(*)(ArgTypes...)) -> function<R(ArgTypes...)>;
  template<class F> function(F) -> function</* 설명 참조 */>;
  // 널 포인터 비교 함수
  template<class R, class... ArgTypes>
    bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
  // 특수화된 알고리즘
  template<class R, class... ArgTypes>
    void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
}

클래스 템플릿 std::move_only_function 

namespace std {
  template<class... S> class move_only_function; // 정의되지 않음
  template<class R, class... ArgTypes>
  class move_only_function<R(ArgTypes...) /*cv-ref*/ noexcept(/*noex*/)> {
  public:
    using result_type = R;
    // 생성/이동/소멸
    move_only_function() noexcept;
    move_only_function(nullptr_t) noexcept;
    move_only_function(move_only_function&&) noexcept;
    template<class F> move_only_function(F&&);
    template<class T, class... Args>
      explicit move_only_function(in_place_type_t<T>, Args&&...);
    template<class T, class U, class... Args>
      explicit move_only_function(in_place_type_t<T>, initializer_list<U>, Args&&...);
    move_only_function& operator=(move_only_function&&);
    move_only_function& operator=(nullptr_t) noexcept;
    template<class F> move_only_function& operator=(F&&);
    ~move_only_function();
    // 호출
    explicit operator bool() const noexcept;
    R operator()(ArgTypes...) /*cv-ref*/ noexcept(/*noex*/);
    // 유틸리티
    void swap(move_only_function&) noexcept;
    friend void swap(move_only_function&, move_only_function&) noexcept;
    friend bool operator==(const move_only_function&, nullptr_t) noexcept;
  private:
    // 설명 전용
    template<class VT>
      static constexpr bool /*is-callable-from*/ = /* 설명 참조 */; 
  };
}

클래스 템플릿 std::copyable_function 

namespace std {
  template<class... S> class copyable_function; // 정의되지 않음
  template<class R, class... ArgTypes>
  class copyable_function<R(ArgTypes...) /*cv-ref*/ noexcept(/*noex*/)> {
  public:
    using result_type = R;
    // 생성/이동/소멸
    copyable_function() noexcept;
    copyable_function(nullptr_t) noexcept;
    copyable_function(const copyable_function&);
    copyable_function(copyable_function&&) noexcept;
    template<class F> copyable_function(F&&);
    template<class T, class... Args>
      explicit copyable_function(in_place_type_t<T>, Args&&...);
    template<class T, class U, class... Args>
      explicit copyable_function(in_place_type_t<T>, initializer_list<U>, Args&&...);
    copyable_function& operator=(const copyable_function&);
    copyable_function& operator=(copyable_function&&);
    copyable_function& operator=(nullptr_t) noexcept;
    template<class F> copyable_function& operator=(F&&);
    ~copyable_function();
    // 호출
    explicit operator bool() const noexcept;
    R operator()(ArgTypes...) /*cv-ref*/ noexcept(/*noex*/);
    // 유틸리티
    void swap(copyable_function&) noexcept;
    friend void swap(copyable_function&, copyable_function&) noexcept;
    friend bool operator==(const copyable_function&, nullptr_t) noexcept;
  private:
    // 설명 전용
    template<class VT>
      static constexpr bool /*is-callable-from*/ = /* 설명 참조 */; 
  };
}

클래스 템플릿 std::function_ref 

namespace std {
  template<class... S> class function_ref; // 정의되지 않음
  template<class R, class... ArgTypes>
  class function_ref<R(ArgTypes...) /*cv*/ noexcept(/*noex*/)> {
  public:
    // 생성자 및 할당 연산자
    template<class F> function_ref(F*) noexcept;
    template<class F> constexpr function_ref(F&&) noexcept;
    template<auto f> constexpr function_ref(nontype_t<f>) noexcept;
    template<auto f, class U>
      constexpr function_ref(nontype_t<f>, U&&) noexcept;
    template<auto f, class T>
      constexpr function_ref(nontype_t<f>, /*cv*/ T*) noexcept;
    constexpr function_ref(const function_ref&) noexcept = default;
    constexpr function_ref& operator=(const function_ref&) noexcept = default;
    template<class T> function_ref& operator=(T) = delete;
    // 호출
    R operator()(ArgTypes...) /*cv*/ noexcept(/*noex*/);
  private:
    // 설명 전용
    template<class... T>
      static constexpr bool /*is-invocable-using*/ = /* 설명 참조 */;
    R (*thunk-ptr)(BoundEntityType, ArgTypes&&...) noexcept(/*noex*/); // 설명 전용
    BoundEntityType bound-entity; // 설명 전용
  };
  // 추론 가이드
  template<class F>
    function_ref(F*) -> function_ref<F>;
  template<auto f>
    function_ref(nontype_t<f>) -> function_ref</* 설명 참조 */>;
  template<auto f, class T>
    function_ref(nontype_t<f>, T&&) -> function_ref</* 설명 참조 */>;
}

클래스 템플릿 std::default_searcher 

namespace std {
  template<class ForwardIter1, class BinaryPredicate = equal_to<>>
    class default_searcher {
    public:
      constexpr default_searcher(ForwardIter1 pat_first, ForwardIter1 pat_last,
                                 BinaryPredicate pred = BinaryPredicate());
      template<class ForwardIter2>
        constexpr pair<ForwardIter2, ForwardIter2>
          operator()(ForwardIter2 first, ForwardIter2 last) const;
    private:
      ForwardIter1 pat_first_;            // 설명 전용
      ForwardIter1 pat_last_;             // 설명 전용
      BinaryPredicate pred_;              // 설명 전용
  };
}

클래스 템플릿 std::boyer_moore_searcher 

namespace std {
  template<class RandomAccessIter1,
           class Hash = hash<typename iterator_traits<RandomAccessIter1>::value_type>,
           class BinaryPredicate = equal_to<>>
    class boyer_moore_searcher {
    public:
      boyer_moore_searcher(RandomAccessIter1 pat_first,
                           RandomAccessIter1 pat_last,
                           Hash hf = Hash(),
                           BinaryPredicate pred = BinaryPredicate());
      template<class RandomAccessIter2>
        pair<RandomAccessIter2, RandomAccessIter2>
          operator()(RandomAccessIter2 first, RandomAccessIter2 last) const;
    private:
      RandomAccessIter1 pat_first_;       // 설명용으로만 사용
      RandomAccessIter1 pat_last_;        // 설명용으로만 사용
      Hash hash_;                         // 설명용으로만 사용
      BinaryPredicate pred_;              // 설명용으로만 사용
    };
}

클래스 템플릿 std::boyer_moore_horspool_searcher 

namespace std {
  template<class RandomAccessIter1,
           class Hash = hash<typename iterator_traits<RandomAccessIter1>::value_type>,
           class BinaryPredicate = equal_to<>>
    class boyer_moore_horspool_searcher {
    public:
      boyer_moore_horspool_searcher(RandomAccessIter1 pat_first,
                                    RandomAccessIter1 pat_last,
                                    Hash hf = Hash(),
                                    BinaryPredicate pred = BinaryPredicate());
      template<class RandomAccessIter2>
        pair<RandomAccessIter2, RandomAccessIter2>
          operator()(RandomAccessIter2 first, RandomAccessIter2 last) const;
    private:
      RandomAccessIter1 pat_first_;       // 설명용으로만 사용
      RandomAccessIter1 pat_last_;        // 설명용으로만 사용
      Hash hash_;                         // 설명용으로만 사용
      BinaryPredicate pred_;              // 설명용으로만 사용
  };
}

참고 항목

std::hash 라이브러리 타입에 대한 특수화