멤버 함수는 일반 함수 포인터에 담을 수 있나요?

멤버 함수는 this 포인터가 함께 있어야 하므로, 자유 함수와 같은 int (*)(int, int) 형태에 직접 담을 수 없습니다. static 멤버는 예외이며, 인스턴스 멤버는 std::function과 std::bind, 람다, 또는 (멤버 포인터 + 객체)를 조합해 사용하세요.

ptr = add와 ptr = &add는 모두 올바른가요?

자유(비멤버) 함수 이름은 대부분의 경우 함수 포인터로 암시적 변환됩니다. &add는 주소를 명시적으로 취한 것이고, add는 동일한 맥락에서 ‘함수로 decay’되어 같은 주소가 됩니다. 둘 다 표준에 맞는 관용적 표기입니다.

함수 포인터와 std::function의 차이는 무엇인가요?

함수 포인터는 호출할 대상의 타입/시그니처가 고정되고 복사·저장 비용이 가볍습니다. std::function은 람다, 바인딩, 함수 객체 등을 한 타입으로 감쌀 수 있으나 type erasure(타입 소거)로 인해 힙 할당·오버헤드가 생길 수 있어, 핫 경로·임베디드·실시간 제약이 있을 때는 함수 포인터·템플릿이 유리한 경우가 많습니다.

C 언어와 연동하거나 C API 콜백에 넣을 때 주의할 점은?

C API는 void (*)(void*) 같은 C 링크 형식이고 예외/멤버 캡처 람다는 사용할 수 없는 경우가 많습니다. C++ 쪽에서는 extern "C"로 선언·정의하거나, 람다는 캡처 없이+함수 포인터로 decay 가능한 시그니처로만 전달하세요. 사용자 데이터는 void* 인자로 넘기는 패턴이 흔합니다.

C++ 함수 포인터 | 'Function Pointer' 가이드

2026년 3월 12일 · 11분 읽기 · 수정 2026년 4월 7일 중급 튜토리얼

이 글의 핵심

int add(int a, int b) { return a + b; }.

함수 포인터란?

함수의 주소를 저장하는 포인터

add 함수의 구현 예제입니다.

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

int main() {
    // 함수 포인터 선언
    int (*funcPtr)(int, int) = add;
    
    // 호출
    int result = funcPtr(3, 4);  // 7
    std::cout << result << std::endl;
}

기본 문법

add 함수의 구현 예제입니다.

// 함수 포인터 선언
int (*ptr)(int, int);

// 함수 할당
int add(int a, int b) { return a + b; }
ptr = add;
// 또는
ptr = &add;

// 호출
int result = ptr(3, 4);
// 또는
int result = (*ptr)(3, 4);

typedef/using으로 간소화

// typedef
typedef int (*Operation)(int, int);

// using (권장)
using Operation = int(*)(int, int);

int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

int main() {
    Operation op = add;
    std::cout << op(3, 4) << std::endl;  // 7
    
    op = multiply;
    std::cout << op(3, 4) << std::endl;  // 12
}

실전 예시

예시 1: 콜백 함수

#include <vector>

void forEach(const std::vector<int>& vec, void (*callback)(int)) {
    for (int x : vec) {
        callback(x);
    }
}

void printValue(int x) {
    std::cout << x << " ";
}

void printSquare(int x) {
    std::cout << x * x << " ";
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    forEach(numbers, printValue);   // 1 2 3 4 5
    std::cout << std::endl;
    
    forEach(numbers, printSquare);  // 1 4 9 16 25
    std::cout << std::endl;
}

예시 2: 계산기

using Operation = int(*)(int, int);

int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }
int divide(int a, int b) { return b != 0 ? a / b : 0; }

int calculate(int a, int b, Operation op) {
    return op(a, b);
}

int main() {
    std::cout << calculate(10, 5, add) << std::endl;       // 15
    std::cout << calculate(10, 5, subtract) << std::endl;  // 5
    std::cout << calculate(10, 5, multiply) << std::endl;  // 50
    std::cout << calculate(10, 5, divide) << std::endl;    // 2
}

예시 3: 함수 테이블

#include <map>
#include <string>

using Command = void(*)();

void cmdHelp() {
    std::cout << "도움말" << std::endl;
}

void cmdQuit() {
    std::cout << "종료" << std::endl;
}

void cmdStatus() {
    std::cout << "상태 확인" << std::endl;
}

int main() {
    std::map<std::string, Command> commands = {
        {"help", cmdHelp},
        {"quit", cmdQuit},
        {"status", cmdStatus}
    };
    
    std::string input;
    while (true) {
        std::cout << "> ";
        std::cin >> input;
        
        if (input == "quit") break;
        
        auto it = commands.find(input);
        if (it != commands.end()) {
            it->second();  // 함수 호출
        } else {
            std::cout << "알 수 없는 명령" << std::endl;
        }
    }
}

예시 4: 정렬 비교 함수

#include <algorithm>
#include <vector>

bool ascending(int a, int b) {
    return a < b;
}

bool descending(int a, int b) {
    return a > b;
}

bool byAbsoluteValue(int a, int b) {
    return std::abs(a) < std::abs(b);
}

void sortVector(std::vector<int>& vec, bool (*compare)(int, int)) {
    std::sort(vec.begin(), vec.end(), compare);
}

int main() {
    std::vector<int> numbers = {-5, 2, -8, 1, 9, -3};
    
    sortVector(numbers, ascending);
    for (int x : numbers) std::cout << x << " ";
    std::cout << std::endl;  // -8 -5 -3 1 2 9
    
    sortVector(numbers, descending);
    for (int x : numbers) std::cout << x << " ";
    std::cout << std::endl;  // 9 2 1 -3 -5 -8
    
    sortVector(numbers, byAbsoluteValue);
    for (int x : numbers) std::cout << x << " ";
    std::cout << std::endl;  // 1 2 -3 -5 -8 9
}

std::function (C++11)

#include <functional>

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

int main() {
    // 함수 포인터
    int (*ptr)(int, int) = add;
    
    // std::function (더 유연)
    std::function<int(int, int)> func = add;
    
    // 람다도 저장 가능
    func =  { return a * b; };
    
    std::cout << func(3, 4) << std::endl;  // 12
}

멤버 함수 포인터

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }
    
    int multiply(int a, int b) {
        return a * b;
    }
};

int main() {
    Calculator calc;
    
    // 멤버 함수 포인터
    int (Calculator::*funcPtr)(int, int) = &Calculator::add;
    
    // 호출
    int result = (calc.*funcPtr)(3, 4);  // 7
    std::cout << result << std::endl;
    
    // 포인터로 호출
    Calculator* ptr = &calc;
    result = (ptr->*funcPtr)(3, 4);
    std::cout << result << std::endl;
}

자주 발생하는 문제

문제 1: 문법 복잡성

C/C++ 예제 코드입니다.

// ❌ 복잡한 문법
int (*funcPtr)(int, int);

// ✅ using으로 간소화
using Operation = int(*)(int, int);
Operation funcPtr;

문제 2: nullptr 체크

using Callback = void(*)();

void execute(Callback cb) {
    // ❌ nullptr 체크 없음
    // cb();  // 크래시 가능
    
    // ✅ nullptr 체크
    if (cb) {
        cb();
    }
}

문제 3: 람다 캡처

C/C++ 예제 코드입니다.

int x = 10;

// ❌ 캡처하는 람다는 함수 포인터 불가
// void (*ptr)() = [x]() { std::cout << x; };  // 에러

// ✅ std::function 사용
std::function<void()> func = [x]() { std::cout << x; };

문제 4: 멤버 함수 포인터

class MyClass {
public:
    void func() {}
};

// ❌ 일반 함수 포인터로 불가
// void (*ptr)() = &MyClass::func;  // 에러

// ✅ 멤버 함수 포인터
void (MyClass::*ptr)() = &MyClass::func;

MyClass obj;
(obj.*ptr)();

함수 포인터 배열

using Operation = int(*)(int, int);

int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }
int divide(int a, int b) { return b != 0 ? a / b : 0; }

int main() {
    Operation operations[] = {add, subtract, multiply, divide};
    
    for (int i = 0; i < 4; i++) {
        std::cout << operations[i](10, 5) << " ";
    }
    std::cout << std::endl;  // 15 5 50 2
}

std::function vs 함수 포인터

#include <functional>

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

int main() {
    // 함수 포인터: 함수만
    int (*ptr)(int, int) = add;
    
    // std::function: 함수, 람다, 함수 객체 모두
    std::function<int(int, int)> func1 = add;
    std::function<int(int, int)> func2 =  { return a * b; };
    
    struct Multiplier {
        int operator()(int a, int b) const {
            return a * b;
        }
    };
    std::function<int(int, int)> func3 = Multiplier();
}

FAQ

Q1: 함수 포인터는 언제 사용?

콜백 함수
함수 테이블
플러그인 시스템

Q2: std::function vs 함수 포인터?

함수 포인터: 빠름, 함수만
std::function: 유연, 람다/함수 객체

Q3: 성능은?

A: 함수 포인터는 간접 호출. 약간의 오버헤드.

Q4: 멤버 함수 포인터는?

A: 다른 문법. &Class::func, (obj.*ptr)()

Q5: nullptr 체크 필요?

A: 네. 안전을 위해 체크 권장.

Q6: 함수 포인터 학습 리소스는?

“C++ Primer”
cppreference.com
“Effective C++“

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

심화 부록: 구현·운영 관점

이 부록은 앞선 본문에서 다룬 주제(「C++ 함수 포인터 | ‘Function Pointer’ 가이드」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(I/O·네트워크·동시성) → 관측의 흐름으로 장애를 나누면 원인 추적이 빨라집니다.

내부 동작과 핵심 메커니즘

flowchart TD
  A[입력·요청·이벤트] --> B[파싱·검증·디코딩]
  B --> C[핵심 연산·상태 전이]
  C --> D[부작용: I/O·네트워크·동시성]
  D --> E[결과·관측·저장]

sequenceDiagram
  participant C as 클라이언트/호출자
  participant B as 경계(런타임·게이트웨이·프로세스)
  participant D as 의존성(API·DB·큐·파일)
  C->>B: 요청/이벤트
  B->>D: 조회·쓰기·RPC
  D-->>B: 지연·부분 실패·재시도 가능
  B-->>C: 응답 또는 오류(코드·상관 ID)

불변 조건(Invariant): 버퍼 경계, 프로토콜 상태, 트랜잭션 격리, FD 상한 등 단계별로 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
결정성: 순수 층과 시간·네트워크·스케줄에 의존하는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
경계 비용: 직렬화, 인코딩, syscall 횟수, 락 경합, 할당·GC, 캐시 미스를 의심 목록에 둡니다.
백프레셔: 생산자가 소비자보다 빠를 때 버퍼·큐·스트림에서 속도를 줄이는 신호를 어디에 둘지 정의합니다.

프로덕션 운영 패턴

영역	운영 관점 질문
관측성	요청 단위 상관 ID, 에러율·지연 p95/p99, 의존성 타임아웃·재시도가 대시보드에 보이는가
안전성	입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가
신뢰성	재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가
성능	캐시·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가
배포	롤백 룬북, 카나리/블루그린, 마이그레이션·피처 플래그가 문서화되어 있는가
용량	피크 트래픽·디스크·FD·스레드 풀 상한을 주기적으로 검증하는가

스테이징은 데이터 양·네트워크 RTT·동시성을 프로덕션에 가깝게 맞출수록 재현율이 올라갑니다.

확장 예시: 엔드투엔드 미니 시나리오

앞선 본문 주제(「C++ 함수 포인터 | ‘Function Pointer’ 가이드」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.

입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값을 점검한다.

handle(request):
  ctx = newCorrelationId()
  validated = validateSchema(request)
  authorize(validated, ctx)
  result = domainCore(validated)
  persistOrEmit(result, idempotentKey)
  recordMetrics(ctx, latency, outcome)
  return result

문제 해결(Troubleshooting)

증상	가능 원인	조치
간헐적 실패	레이스, 타임아웃, 외부 의존성, DNS	최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검
성능 저하	N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스	프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거
메모리 증가	캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납	상한·TTL·힙/FD 스냅샷 비교
빌드·배포만 실패	환경 변수, 권한, 플랫폼 차이, lockfile	CI 로그와 로컬 diff, 런타임·이미지 버전 핀
설정 불일치	프로필·시크릿·기본값, 리전	스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화
데이터 불일치	비멱등 재시도, 부분 쓰기, 캐시 무효화 누락	멱등 키·아웃박스·트랜잭션 경계 재검토

권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.

배포 전에는 git add → git commit → git push 후 npm run deploy 순서를 권장합니다.

이 글에서 다루는 키워드 (관련 검색어)

C++, function-pointer, callback, 함수포인터, 콜백 등으로 검색하시면 이 글이 도움이 됩니다.

이 글이 도움이 되셨나요?

여러분의 피드백은 더 나은 콘텐츠를 만드는 데 도움이 됩니다

문제가 있거나 개선 제안이 있으시면 연락처로 알려주세요.

Keyboard Shortcuts