[C++] std::function : 호출 가능한 대상을 하나의 타입으로

[C++] std::function : 호출 가능한 대상을 하나의 타입으로

안녕하세요. 이번 글에서는 C++11에서 추가된 std::function에 대해 알아보겠습니다.

C++에서 “호출할 수 있는 것”은 여러 종류가 있습니다. 일반 함수, 함수 포인터, operator()를 가진 함수 객체, 람다가 모두 호출 가능하지만 타입은 서로 다릅니다. 특히 람다는 컴파일러가 만든 고유한 타입이라 변수나 멤버로 저장하기가 까다롭습니다. std::function은 시그니처(반환형과 매개변수)만 맞으면 이들을 하나의 타입으로 감싸서 저장하고 호출할 수 있게 해 줍니다. 콜백, 이벤트 핸들러를 구현할 때 자주 쓰입니다.

기본 사용법

헤더는 <functional>입니다. 템플릿 인자에 반환형(매개변수…) 형태로 시그니처를 적습니다. 예를 들어 int 두 개를 받아 int를 돌려주는 함수는 function<int(int, int)>로 표현합니다.

#include <functional>
#include <iostream>
using namespace std;

int Add(int a, int b) { return a + b; }

struct Multiply
{
    int operator()(int a, int b) const { return a * b; }
};

int main()
{
    function<int(int, int)> op;

    op = Add;                                   // 일반 함수
    cout << op(3, 4) << "\n";                   // 7

    op = Multiply();                            // 함수 객체
    cout << op(3, 4) << "\n";                   // 12

    op = [](int a, int b) { return a - b; };    // 람다
    cout << op(3, 4) << "\n";                   // -1
}

실행 결과

7
12
-1

같은 변수 op에 일반 함수, 함수 객체, 람다를 차례로 대입했습니다. 시그니처만 같으면 원래 타입이 무엇이든 상관없습니다.

주요 기능

기능설명
operator()감싸고 있는 대상을 호출
operator bool대상이 들어 있으면 true, 비어 있으면 false
= nullptr대상을 비움
swap()다른 function과 내용을 교환
target<T>()저장된 대상이 T 타입이면 그 포인터, 아니면 nullptr

콜백 저장하기

std::function의 가장 큰 장점은 컨테이너나 멤버 변수에 저장할 수 있다는 점입니다. 아래는 버튼 클릭 시 등록된 핸들러를 모두 호출하는 간단한 예제입니다. 캡처가 있는 람다도 그대로 등록할 수 있습니다.

#include <functional>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Button
{
public:
    void AddClickHandler(function<void(const string&)> handler)
    {
        m_handlers.push_back(handler);
    }

    void Click()
    {
        for (auto& handler : m_handlers)
            handler(m_name);
    }

    explicit Button(string name) : m_name(move(name)) {}

private:
    string m_name;
    vector<function<void(const string&)>> m_handlers;
};

int main()
{
    int clickCount = 0;
    Button button("OK");

    button.AddClickHandler([](const string& name) {
        cout << name << " 버튼 클릭\n";
    });
    button.AddClickHandler([&clickCount](const string&) {
        ++clickCount;
    });

    button.Click();
    button.Click();
    cout << "클릭 횟수: " << clickCount << "\n";   // 2
}

실행 결과

OK 버튼 클릭
OK 버튼 클릭
클릭 횟수: 2

vector<function<void(const string&)>>에 서로 다른 람다 두 개를 담았습니다. 람다마다 타입이 다르지만 function으로 감쌌기 때문에 한 컨테이너에 함께 넣을 수 있습니다.

빈 function 호출

기본 생성한 function은 아무 대상도 갖지 않습니다. 이 상태에서 호출하면 std::bad_function_call 예외가 발생하므로, 호출 전에 bool 변환으로 확인하는 것이 안전합니다.

#include <functional>
#include <iostream>
using namespace std;

int main()
{
    function<void()> callback;

    if (!callback)
        cout << "비어 있음\n";

    try
    {
        callback();     // 빈 function 호출
    }
    catch (const bad_function_call& e)
    {
        cout << "예외: " << e.what() << "\n";
    }

    callback = [] { cout << "호출됨\n"; };
    if (callback)
        callback();

    callback = nullptr;  // 다시 비우기
    cout << boolalpha << static_cast<bool>(callback) << "\n";  // false
}

실행 결과

비어 있음
예외: bad_function_call
호출됨
false

예외 메시지(what()의 내용)는 컴파일러마다 다를 수 있습니다.

함수 포인터, 템플릿과 비교

호출 가능한 대상을 매개변수로 받는 방법은 std::function 외에도 함수 포인터와 템플릿이 있습니다. 각각 장단점이 있습니다.

#include <functional>
#include <iostream>
using namespace std;

// 1) 함수 포인터 : 캡처 없는 람다·일반 함수만 받음
int ApplyPtr(int (*f)(int), int x) { return f(x); }

// 2) std::function : 캡처 있는 람다도 받음
int ApplyFunc(const function<int(int)>& f, int x) { return f(x); }

// 3) 템플릿 : 타입을 그대로 받음 (가장 빠름, 저장은 불편)
template <typename F>
int ApplyTmpl(F f, int x) { return f(x); }

int main()
{
    int offset = 10;
    auto plus = [offset](int x) { return x + offset; };

    // ApplyPtr(plus, 1);                    // 오류 : 캡처가 있으면 함수 포인터로 변환 불가
    cout << ApplyPtr([](int x) { return x * 2; }, 1) << "\n";  // 2
    cout << ApplyFunc(plus, 1) << "\n";                         // 11
    cout << ApplyTmpl(plus, 1) << "\n";                         // 11
}

실행 결과

2
11
11
방식캡처 있는 람다저장(멤버·컨테이너)성능
함수 포인터받을 수 없음가능빠름
std::function가능가능간접 호출 비용, 경우에 따라 힙 할당
템플릿 매개변수가능어려움(타입이 고정됨)가장 빠름(인라인 가능)

정리하면, 호출 대상을 저장해 두었다가 나중에 호출해야 할 때는 std::function이 편하고, 바로 호출하고 끝나는 알고리즘 형태의 함수라면 템플릿이 더 효율적입니다.

주의할 점

  • std::function은 대상을 감싸기 위해 타입 소거(type erasure)를 사용합니다. 호출할 때마다 간접 호출이 일어나고, 큰 람다를 담으면 힙 할당이 발생할 수 있습니다. 성능이 중요한 반복문 안에서는 템플릿이 유리합니다.
  • 참조로 캡처한 람다([&])를 function에 저장할 때는 캡처한 변수가 function보다 오래 살아 있어야 합니다. 지역 변수를 참조 캡처한 콜백을 등록하고 함수를 빠져나가면 dangling 참조가 됩니다.
  • std::function은 복사 가능한 대상만 담을 수 있습니다. unique_ptr을 이동 캡처한 람다처럼 복사할 수 없는 대상은 담을 수 없으며, C++23의 std::move_only_function이 이런 경우를 위해 추가되었습니다.
  • 두 function 객체끼리 == 로 비교할 수 없습니다. nullptr과의 비교만 가능합니다.

참고

이상으로 std::function에 대해 간단히 알아보았습니다.