Namespaces
Variants

    std::function

    cppreference.net에서
     
    C++
     
    유틸리티 라이브러리
    일반 유틸리티
    관계 연산자 (C++20에서 폐지됨)
    정수 비교 함수
    (C++20)(C++20)(C++20)    
    (C++20)
    스왑 및 타입 연산
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    공통 어휘 타입
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    함수 객체
    함수 호출
    (C++17)(C++23)
    항등 함수 객체
    (C++20)
    투명 연산자 래퍼
    (C++14)
    (C++14)
    (C++14)
    (C++14)  
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)

    구 바인더와 어댑터
    (C++17까지*)
    (C++17까지*)
    (C++17까지*)
    (C++17까지*)
    (C++17까지*)  
    (C++17까지*)
    (C++17까지*)(C++17까지*)(C++17까지*)(C++17까지*)
    (C++20까지*)
    (C++20까지*)
    (C++17까지*)(C++17까지*)
    (C++17까지*)(C++17까지*)

    (C++17까지*)
    (C++17까지*)(C++17까지*)(C++17까지*)(C++17까지*)
    (C++20까지*)
    (C++20까지*)
     
    std::function
     
    헤더 <functional> 
    template< class >
class function; /* undefined */
    		에 정의됨 
    template< class R, class... Args >
class function<R(Args...)>;
    		(C++11 이후)

    클래스 템플릿 std::function은 범용 다형성 함수 래퍼입니다. std::function의 인스턴스는 CopyConstructible Callable 대상 — 함수 (함수에 대한 포인터를 통해), 람다 표현식, 바인드 표현식, 또는 기타 함수 객체와 멤버 함수에 대한 포인터 및 데이터 멤버에 대한 포인터를 저장, 복사 및 호출할 수 있습니다.

    저장된 호출 가능 객체를 대상이라고 합니다. std::function에 대상이 없으면 이를 std::function비어 있음(empty)이라고 합니다. 비어 있음(empty) 의 비어 있음(empty) std::function 대상을 호출하면 std::bad_function_call 예외가 발생합니다.

    std::function은 CopyConstructible 및 CopyAssignable 요구 사항을 충족합니다.

    멤버 타입

    유형 정의
    result_type R
    argument_type
    (C++17에서 사용 중단됨) (C++20에서 제거됨)     		T 만약 sizeof... ( Args ) == 1 이고 T 가 Args... 에서 첫 번째이자 유일한 타입인 경우
    first_argument_type
    (C++17에서 사용 중단됨) (C++20에서 제거됨)     		T1 만약 sizeof... ( Args ) == 2 이고 T1 가 Args... 에서 두 타입 중 첫 번째 타입인 경우
    second_argument_type
    (C++17에서 사용 중단됨) (C++20에서 제거됨)     		T2 만약 sizeof... ( Args ) == 2 이고 T2 가 Args... 에서 두 타입 중 두 번째 타입인 경우

    멤버 함수

    		새로운 std::function 인스턴스를 생성
    (public member function)
    		std::function 인스턴스를 파괴
    (public member function)
    		새로운 대상을 할당
    (public member function)
    		내용을 교환
    (public member function)
    (removed in C++17)
    		새로운 대상을 할당
    (public member function)
    		대상 포함 여부를 확인
    (public member function)
    		대상을 호출
    (public member function)
    대상 접근
    		저장된 대상의 typeid 를 획득
    (public member function)
    		저장된 대상에 대한 포인터를 획득
    (public member function)

    비멤버 함수

    (C++11)
    		std::swap 알고리즘을 특수화함
    (함수 템플릿)
    (C++20에서 제거됨)
    		std::function 과 nullptr 을 비교함
    (함수 템플릿)

    헬퍼 클래스

    (C++11) (until C++17)
    		std::uses_allocator 타입 특성의 특수화
    (클래스 템플릿 특수화)

    추론 가이드 (C++17부터)

    참고 사항

    후행 반환 타입이 없는 람다 표현식에서 참조를 결과 타입으로 하는 std::function 을 초기화할 때는 주의해야 합니다. auto 추론 방식 때문에 이러한 람다 표현식은 항상 prvalue를 반환합니다. 따라서 결과 참조는 일반적으로 std::function::operator() 이 반환될 때 수명이 끝나는 임시 객체에 바인딩됩니다.

    		(C++23 이전)

    참조를 반환하는 std::function 이 prvalue를 반환하는 함수나 함수 객체(후행 반환 타입이 없는 람다 표현식 포함)로부터 초기화되면, 반환된 참조가 임시 객체에 바인딩되는 것이 금지되므로 프로그램의 형식이 올바르지 않습니다.

    		(C++23 이후) 
    std::function<const int&()> F([] { return 42; }); // C++23부터 오류: 반환된 참조를 임시 객체에 바인딩할 수 없음
                                                  // the returned reference to a temporary
int x = F(); // C++23까지 미정의 동작: F()의 결과는 매달린 참조(dangling reference)
std::function<int&()> G([]() -> int& { static int i{0x2A}; return i; }); // 정상
std::function<const int&()> H([i{052}] -> const int& { return i; }); // 정상

    예제

    이 코드 실행 
    #include <functional>
#include <iostream>
struct Foo
{
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_ + i << '\n'; }
    int num_;
};
void print_num(int i)
{
    std::cout << i << '\n';
}
struct PrintNum
{
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};
int main()
{
    // 자유 함수 저장
    std::function<void(int)> f_display = print_num;
    f_display(-9);
    // 람다 저장
    std::function<void()> f_display_42 = []() { print_num(42); };
    f_display_42();
    // std::bind 호출 결과 저장
    std::function<void()> f_display_31337 = std::bind(print_num, 31337);
    f_display_31337();
    // 멤버 함수 호출 저장
    std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
    const Foo foo(314159);
    f_add_display(foo, 1);
    f_add_display(314159, 1);
    // 데이터 멤버 접근자 호출 저장
    std::function<int(Foo const&)> f_num = &Foo::num_;
    std::cout << "num_: " << f_num(foo) << '\n';
    // 멤버 함수와 객체 호출 저장
    using std::placeholders::_1;
    std::function<void(int)> f_add_display2 = std::bind(&Foo::print_add, foo, _1);
    f_add_display2(2);
    // 멤버 함수와 객체 포인터 호출 저장
    std::function<void(int)> f_add_display3 = std::bind(&Foo::print_add, &foo, _1);
    f_add_display3(3);
    // 함수 객체 호출 저장
    std::function<void(int)> f_display_obj = PrintNum();
    f_display_obj(18);
    auto factorial = [](int n)
    {
        // "재귀적 람다"를 모방하기 위해 람다 객체 저장; 추가 오버헤드 인지
        std::function<int(int)> fac = [&](int n) { return (n < 2) ? 1 : n * fac(n - 1); };
        // "auto fac = [&](int n) {...};"는 재귀 호출에서 작동하지 않음에 유의
        return fac(n);
    };
    for (int i{5}; i != 8; ++i)
        std::cout << i << "! = " << factorial(i) << ";  ";
    std::cout << '\n';
}

    가능한 출력: 

    -9
42
31337
314160
314160
num_: 314159
314161
314162
18
5! = 120;  6! = 720;  7! = 5040;

    참고 항목

    (C++23)
    		주어진 호출 시그니처에서 한정자를 지원하는 모든 호출 가능 객체의 이동 전용 래퍼
    (클래스 템플릿)
    (C++26)
    		주어진 호출 시그니처에서 한정자를 지원하는 모든 복사 생성 가능 호출 가능 객체의 복사 가능 래퍼
    (클래스 템플릿)
    (C++26)
    		모든 호출 가능 객체의 비소유 래퍼
    (클래스 템플릿)
    (C++11)
    		빈 std::function 을 호출할 때 발생하는 예외
    (클래스)
    (C++11)
    		멤버에 대한 포인터로부터 함수 객체를 생성함
    (함수 템플릿)
    typeid 타입 정보를 질의하며, 해당 타입을 나타내는 std::type_info 객체를 반환함