MENU
  1. ホーム
  2. C 언어
  3. C 언어에서 함수 포인터를 활용한 모듈화된 코드 작성 방법

C 언어에서 함수 포인터를 활용한 모듈화된 코드 작성 방법

C 언어

C 언어는 시스템 프로그래밍 언어로서 성능과 제어의 유연성을 제공합니다. 이 중 함수 포인터는 코드의 동작 방식을 동적으로 변경할 수 있는 강력한 도구입니다. 이를 활용하면 실행 시점에서 함수를 선택하거나 다형성을 구현하는 등, 기존의 정적 코드 구조를 보다 유연하게 만들 수 있습니다. 본 기사에서는 함수 포인터의 기본 개념부터 실전 예제까지 다루며, 이를 통해 모듈화된 코드를 작성하는 방법을 상세히 설명합니다. C 언어의 진정한 잠재력을 발휘하기 위한 시작점으로 삼으세요.

목차

함수 포인터의 개념과 기본 문법


함수 포인터는 C 언어에서 함수의 주소를 저장할 수 있는 포인터입니다. 이를 통해 프로그램 실행 중 특정 함수를 호출하도록 유연한 코드를 작성할 수 있습니다.

함수 포인터의 정의


함수 포인터는 특정 함수의 주소를 가리키며, 이를 사용해 해당 함수를 호출할 수 있습니다. 함수의 시그니처(반환형과 매개변수)가 동일한 경우에만 해당 함수의 주소를 저장할 수 있습니다.

기본 문법


다음은 함수 포인터의 선언, 초기화, 사용의 기본 문법입니다.

#include <stdio.h>

// 함수 선언
int add(int a, int b) {
    return a + b;
}

int main() {
    // 함수 포인터 선언
    int (*func_ptr)(int, int);

    // 함수 포인터 초기화
    func_ptr = &add; // 또는 func_ptr = add;

    // 함수 포인터를 통한 함수 호출
    int result = func_ptr(3, 4);

    printf("Result: %d\n", result); // Output: Result: 7

    return 0;
}

함수 포인터의 주요 요소

  • 반환형과 매개변수: 함수 포인터는 함수의 반환형과 매개변수가 동일한 함수만 참조할 수 있습니다.
  • (*ptr) 구문: 함수 포인터를 호출할 때는 * 연산자를 사용하여 함수처럼 호출합니다.

함수 포인터는 함수의 동적 선택, 콜백 함수 구현 등 다양한 활용이 가능합니다. 이를 통해 코드의 유연성과 확장성을 높일 수 있습니다.

함수 포인터를 사용하는 이유


함수 포인터는 정적 함수 호출에 비해 코드의 유연성과 모듈화를 향상시키는 데 중요한 역할을 합니다. 이 섹션에서는 함수 포인터를 사용하는 주요 이유를 살펴봅니다.

코드 모듈화와 재사용성


함수 포인터는 코드의 특정 동작을 분리하고, 실행 시점에서 이를 동적으로 결정할 수 있도록 합니다. 이를 통해 중복 코드를 줄이고, 모듈화된 코드를 작성할 수 있습니다.

예시: 정렬 함수에서 비교 기준 변경
함수 포인터를 사용하면 정렬 기준을 런타임에 변경할 수 있습니다.

#include <stdio.h>
#include <stdlib.h>

// 오름차순 비교 함수
int ascending(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

// 내림차순 비교 함수
int descending(const void *a, const void *b) {
    return (*(int *)b - *(int *)a);
}

int main() {
    int arr[] = {5, 2, 9, 1, 6};
    size_t size = sizeof(arr) / sizeof(arr[0]);

    // 함수 포인터로 정렬 기준 선택
    int (*compare)(const void *, const void *) = ascending;

    qsort(arr, size, sizeof(int), compare);

    for (size_t i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

실행 시점의 동적 결정


함수 포인터를 사용하면 프로그램이 실행 중에 특정 함수를 선택할 수 있습니다. 이는 플러그인 시스템이나 상태 관리와 같은 응용 프로그램에서 유용합니다.

콜백 함수 구현


함수 포인터는 이벤트 처리나 특정 작업을 완료한 후 추가 작업을 정의할 때 유용합니다. 콜백 함수는 GUI, 네트워크, 데이터 처리 등 다양한 분야에서 활용됩니다.

다형성 구현


C 언어는 클래스나 객체를 지원하지 않지만, 함수 포인터를 사용하면 객체 지향 언어에서 제공하는 다형성과 유사한 동작을 구현할 수 있습니다. 이는 코드의 확장성과 유지보수성을 높입니다.

유지보수성과 테스트 용이성


코드를 작은 모듈로 분리하고 함수 포인터로 동작을 정의하면, 변경 사항이 국한되고, 테스트가 간단해집니다.

함수 포인터는 이러한 이유들로 인해 복잡한 프로그램에서도 유연하고 확장 가능한 코드를 작성하는 데 필수적인 도구입니다.

함수 포인터와 콜백 함수


콜백 함수는 특정 작업이 완료된 후 호출되는 함수로, 함수 포인터를 통해 구현됩니다. 이를 사용하면 프로그램의 동작을 유연하게 설계할 수 있습니다.

콜백 함수의 개념


콜백 함수는 호출자가 미리 정의한 함수로, 일반적으로 라이브러리나 API에서 실행 중 특정 이벤트가 발생했을 때 호출됩니다. 함수 포인터를 통해 콜백 함수를 등록하거나 호출할 수 있습니다.

콜백 함수 구현 예제


아래는 함수 포인터를 사용해 콜백 함수를 구현하는 간단한 예제입니다.

#include <stdio.h>

// 콜백 함수의 정의
void onComplete(int result) {
    printf("Operation completed with result: %d\n", result);
}

// 함수 포인터를 사용해 작업 수행 후 콜백 호출
void performOperation(int a, int b, void (*callback)(int)) {
    int sum = a + b;
    // 작업 완료 후 콜백 함수 호출
    callback(sum);
}

int main() {
    // performOperation에 콜백 함수 전달
    performOperation(5, 7, onComplete);

    return 0;
}

콜백 함수의 주요 활용 사례

  • 이벤트 처리: GUI 프로그램에서 버튼 클릭, 키보드 입력 등의 이벤트에 반응하는 함수 구현.
  • 데이터 처리: 데이터베이스 쿼리 완료, 파일 읽기/쓰기 작업 후 호출되는 후속 작업.
  • 타이머 및 스케줄링: 일정 시간 후 실행할 작업을 콜백으로 정의.

함수 포인터를 사용한 콜백 등록


일부 라이브러리나 API에서는 콜백 함수를 동적으로 등록하도록 설계되어 있습니다. 예를 들어, 타이머 이벤트를 처리하기 위한 콜백 등록은 다음과 같이 구현할 수 있습니다.

#include <stdio.h>
#include <unistd.h>

// 타이머 콜백 함수
void timerCallback(int seconds) {
    printf("Timer expired after %d seconds\n", seconds);
}

// 타이머 기능 구현
void startTimer(int seconds, void (*callback)(int)) {
    sleep(seconds); // 지정한 시간 동안 대기
    callback(seconds); // 시간 경과 후 콜백 호출
}

int main() {
    // 타이머 시작과 콜백 등록
    startTimer(3, timerCallback);

    return 0;
}

콜백 함수와 함수 포인터의 장점

  • 유연성: 특정 동작을 실행 중에 변경 가능.
  • 모듈화: 코드를 더 작은 단위로 분리하고, 각 단위를 독립적으로 테스트 가능.
  • 재사용성: 콜백 함수의 구현만 변경하여 다양한 동작을 구현 가능.

콜백 함수는 함수 포인터와 결합해 다양한 상황에서 동적이고 유연한 동작을 가능하게 합니다. 이를 통해 보다 강력한 프로그램을 설계할 수 있습니다.

모듈화를 위한 함수 포인터 활용 사례


함수 포인터는 코드의 유연성과 재사용성을 높이는 데 중요한 도구로, 다양한 프로그램 모듈에서 활용됩니다. 이 섹션에서는 함수 포인터를 활용해 모듈화된 코드를 작성하는 구체적인 사례를 살펴봅니다.

함수 포인터를 활용한 다형성 구현


다형성은 객체 지향 프로그래밍의 주요 개념 중 하나로, 동일한 인터페이스로 다양한 동작을 실행할 수 있게 합니다. C 언어에서는 함수 포인터를 활용해 다형성을 구현할 수 있습니다.

예제: 다양한 연산을 수행하는 계산기

#include <stdio.h>

// 연산 함수 정의
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

// 함수 포인터를 활용한 다형성
int calculate(int a, int b, int (*operation)(int, int)) {
    return operation(a, b);
}

int main() {
    int x = 10, y = 5;

    // 연산을 선택적으로 수행
    printf("Addition: %d\n", calculate(x, y, add));       // Output: 15
    printf("Subtraction: %d\n", calculate(x, y, subtract)); // Output: 5

    return 0;
}

플러그인 기반 설계


함수 포인터는 동적으로 실행할 기능을 변경하는 플러그인 시스템에서 유용하게 사용됩니다.

예제: 플러그인 시스템의 기본 구조

#include <stdio.h>

// 플러그인 함수 선언
void pluginA() {
    printf("Plugin A executed.\n");
}

void pluginB() {
    printf("Plugin B executed.\n");
}

// 플러그인 실행 함수
void executePlugin(void (*plugin)()) {
    plugin();
}

int main() {
    // 플러그인 선택 및 실행
    void (*selectedPlugin)() = pluginA;
    executePlugin(selectedPlugin);

    selectedPlugin = pluginB;
    executePlugin(selectedPlugin);

    return 0;
}

상태 기반 동작 관리


프로그램의 상태에 따라 다른 동작을 수행해야 할 때 함수 포인터를 사용하면 상태 전환을 유연하게 처리할 수 있습니다.

예제: 상태 기반 메뉴 시스템

#include <stdio.h>

// 상태 함수 정의
void state1() {
    printf("State 1: Display menu.\n");
}

void state2() {
    printf("State 2: Execute option.\n");
}

// 상태 전환 함수
void switchState(int state, void (*stateFunctions[])()) {
    stateFunctions[state]();
}

int main() {
    void (*stateFunctions[2])() = {state1, state2};

    // 상태 전환
    switchState(0, stateFunctions);
    switchState(1, stateFunctions);

    return 0;
}

장점

  • 코드의 유연성 향상: 실행 중 동작 변경 가능.
  • 모듈화된 설계: 코드의 각 부분을 독립적으로 설계하고 결합 가능.
  • 확장 용이성: 새 기능 추가 시 기존 코드를 최소한으로 수정.

함수 포인터를 활용한 모듈화는 다양한 프로그램 구조를 구현할 수 있는 강력한 방법입니다. 이를 통해 코드의 유지보수성과 확장성을 크게 향상시킬 수 있습니다.

함수 포인터와 구조체의 결합


C 언어에서 함수 포인터를 구조체와 결합하면 객체 지향 언어의 클래스와 유사한 설계를 구현할 수 있습니다. 이 접근법은 상태와 동작을 하나의 단위로 묶어 코드의 가독성과 재사용성을 높이는 데 유용합니다.

구조체 내 함수 포인터의 기본 개념


구조체는 데이터를 저장하는 데 주로 사용되지만, 함수 포인터를 멤버로 포함하면 데이터와 동작을 결합한 모듈을 만들 수 있습니다. 이를 통해 코드의 구조를 더욱 체계적으로 관리할 수 있습니다.

구조체와 함수 포인터의 구현


예제: 간단한 도형 인터페이스
아래 예제에서는 구조체에 함수 포인터를 포함하여 도형의 동작(넓이 계산)을 구현합니다.

#include <stdio.h>

// 도형 구조체 정의
typedef struct {
    double (*calculateArea)(double, double); // 함수 포인터
} Shape;

// 사각형 넓이 계산 함수
double rectangleArea(double width, double height) {
    return width * height;
}

// 삼각형 넓이 계산 함수
double triangleArea(double base, double height) {
    return 0.5 * base * height;
}

int main() {
    // 사각형과 삼각형 도형 생성
    Shape rectangle = {rectangleArea};
    Shape triangle = {triangleArea};

    // 넓이 계산
    printf("Rectangle area: %.2f\n", rectangle.calculateArea(5.0, 4.0));
    printf("Triangle area: %.2f\n", triangle.calculateArea(5.0, 4.0));

    return 0;
}

상태와 동작의 결합


구조체 내 상태 데이터와 함수 포인터를 결합하면 객체 지향 언어의 클래스와 유사한 설계를 구현할 수 있습니다.

예제: 동물의 행동 시스템

#include <stdio.h>

// 동물 구조체 정의
typedef struct {
    const char *name;
    void (*speak)(); // 함수 포인터
} Animal;

// 동물 행동 정의
void dogSpeak() {
    printf("Woof! Woof!\n");
}

void catSpeak() {
    printf("Meow! Meow!\n");
}

int main() {
    // 동물 객체 생성
    Animal dog = {"Dog", dogSpeak};
    Animal cat = {"Cat", catSpeak};

    // 동물 행동 호출
    printf("%s says: ", dog.name);
    dog.speak();

    printf("%s says: ", cat.name);
    cat.speak();

    return 0;
}

구조체와 함수 포인터 결합의 장점

  • 캡슐화: 데이터와 동작을 하나로 묶어 코드의 논리적 구조를 강화.
  • 확장성: 구조체의 함수 포인터를 변경하거나 추가하여 새로운 동작 구현 가능.
  • 유지보수성: 코드의 각 부분을 독립적으로 관리하여 수정이 용이.

응용 사례

  • 게임 개발: 캐릭터 또는 객체의 상태와 동작 정의.
  • GUI 시스템: 버튼과 같은 위젯의 동작과 속성 결합.
  • 상태 관리 시스템: 각 상태에 따른 동작 정의 및 전환.

구조체와 함수 포인터의 결합은 C 언어에서 객체 지향 패턴을 구현하고자 할 때 매우 유용하며, 다양한 상황에서 적용 가능합니다. 이를 통해 모듈화되고 유지보수성이 높은 코드를 작성할 수 있습니다.

실습: 함수 포인터 기반 상태 관리 시스템


상태 관리 시스템은 프로그램이 다양한 상태를 처리하고 전환하는 데 사용됩니다. 함수 포인터를 사용하면 각 상태를 별도의 함수로 정의하고, 실행 중에 상태를 유연하게 전환할 수 있습니다. 이 실습에서는 함수 포인터를 활용한 간단한 상태 관리 시스템을 구현합니다.

상태 관리 시스템 설계

  • 각 상태는 특정 동작을 수행하는 함수로 정의됩니다.
  • 현재 상태를 가리키는 함수 포인터를 통해 상태를 전환합니다.
  • 상태 전환 로직은 시스템의 중심에 위치합니다.

코드 예제: 상태 기반 시스템


아래는 함수 포인터를 사용해 3가지 상태를 관리하는 간단한 시스템입니다.

#include <stdio.h>

// 상태 함수 정의
void stateIdle() {
    printf("System is idle.\n");
}

void stateRunning() {
    printf("System is running.\n");
}

void stateStopped() {
    printf("System is stopped.\n");
}

// 상태 전환 함수
void transitionTo(void (**currentState)(), void (*newState)()) {
    *currentState = newState;
}

int main() {
    // 초기 상태 정의
    void (*currentState)() = stateIdle;

    // 초기 상태 실행
    currentState();

    // 상태 전환
    transitionTo(&currentState, stateRunning);
    currentState();

    transitionTo(&currentState, stateStopped);
    currentState();

    return 0;
}

코드 분석

  1. 상태 정의: stateIdle, stateRunning, stateStopped는 각각의 상태를 나타내는 함수입니다.
  2. 현재 상태 포인터: currentState는 현재 활성화된 상태를 가리킵니다.
  3. 상태 전환: transitionTo 함수는 상태를 전환하고, 새로운 상태를 실행합니다.

응용: 사용자 입력에 따른 상태 전환


사용자 입력을 기반으로 상태를 동적으로 변경할 수 있습니다.

#include <stdio.h>

// 상태 함수 정의
void stateIdle() {
    printf("System is idle.\n");
}

void stateRunning() {
    printf("System is running.\n");
}

void stateStopped() {
    printf("System is stopped.\n");
}

// 상태 전환 함수
void transitionTo(void (**currentState)(), void (*newState)()) {
    *currentState = newState;
}

int main() {
    void (*currentState)() = stateIdle;
    char input;

    while (1) {
        printf("Enter command (i: idle, r: running, s: stopped, q: quit): ");
        scanf(" %c", &input);

        if (input == 'q') {
            break;
        }

        switch (input) {
            case 'i':
                transitionTo(&currentState, stateIdle);
                break;
            case 'r':
                transitionTo(&currentState, stateRunning);
                break;
            case 's':
                transitionTo(&currentState, stateStopped);
                break;
            default:
                printf("Invalid command.\n");
                continue;
        }

        currentState();
    }

    return 0;
}

결과

  • 사용자 입력에 따라 시스템 상태가 동적으로 변경됩니다.
  • 상태 전환 로직은 함수 포인터를 통해 간결하고 효율적으로 구현됩니다.

장점

  • 유연성: 새로운 상태를 쉽게 추가 가능.
  • 모듈화: 각 상태가 독립적으로 관리되어 코드 유지보수가 용이.
  • 확장성: 복잡한 상태 전환 로직을 구현하기 적합.

이 예제는 함수 포인터를 활용한 상태 관리의 기본을 보여주며, 게임 개발, 이벤트 처리, 작업 스케줄링 등 다양한 응용 분야에서 확장하여 사용할 수 있습니다.

함수 포인터 사용 시 주의사항


함수 포인터는 강력한 기능을 제공하지만, 잘못된 사용은 심각한 오류를 초래할 수 있습니다. 이 섹션에서는 함수 포인터를 사용할 때 주의해야 할 사항과 이를 방지하기 위한 모범 사례를 살펴봅니다.

1. 함수 시그니처 일치


함수 포인터는 특정 반환형과 매개변수 시그니처를 갖는 함수만 가리킬 수 있습니다. 함수 시그니처가 일치하지 않으면 컴파일 오류나 런타임 오류가 발생할 수 있습니다.

잘못된 예

void exampleFunc() {
    printf("Example function.\n");
}

int main() {
    void (*funcPtr)(int); // 시그니처 불일치
    funcPtr = exampleFunc; // 오류 발생 가능
    return 0;
}

올바른 예

void exampleFunc() {
    printf("Example function.\n");
}

int main() {
    void (*funcPtr)(); // 시그니처 일치
    funcPtr = exampleFunc;
    funcPtr();
    return 0;
}

2. 초기화되지 않은 함수 포인터


초기화되지 않은 함수 포인터를 호출하면 프로그램이 예기치 않게 종료되거나 비정상적으로 동작할 수 있습니다.

예방 방법: 함수 포인터를 선언할 때 반드시 초기화하거나 NULL로 초기화한 후 확인 과정을 추가합니다.

#include <stdio.h>

void exampleFunc() {
    printf("Function called.\n");
}

int main() {
    void (*funcPtr)() = NULL; // 초기화

    if (funcPtr) {
        funcPtr();
    } else {
        printf("Function pointer is NULL.\n");
    }

    return 0;
}

3. 잘못된 함수 호출


함수 포인터를 잘못된 방식으로 호출하면 런타임 오류가 발생할 수 있습니다. 항상 올바른 호출 구문을 사용해야 합니다.

예시

void exampleFunc() {
    printf("Example function.\n");
}

int main() {
    void (*funcPtr)() = exampleFunc;

    // 잘못된 호출 (함수 포인터 자체를 함수처럼 사용)
    // funcPtr(); -> OK
    // (*funcPtr)(); -> OK
    funcPtr(); // 권장 방식

    return 0;
}

4. 함수 포인터의 잘못된 주소 사용


함수 포인터가 잘못된 메모리 주소를 가리키면 프로그램이 충돌하거나 비정상적으로 동작합니다.

모범 사례: 항상 유효한 함수 주소만 할당하거나, 필요하지 않을 경우 NULL로 초기화합니다.

5. 디버깅 어려움


함수 포인터 사용 시 문제 발생 지점을 추적하기 어려운 경우가 많습니다.
해결 방안: 디버깅 메시지를 추가하거나 함수 포인터 이름에 의미를 부여하여 가독성을 높입니다.

#include <stdio.h>

typedef void (*OperationFunc)();

void logMessage(const char *message) {
    printf("Log: %s\n", message);
}

int main() {
    OperationFunc func = logMessage;
    func("Function pointer is working!");
    return 0;
}

6. 함수 포인터의 크로스 플랫폼 이슈


일부 플랫폼에서는 함수 포인터의 크기가 다를 수 있습니다.
권장 사항: 플랫폼별 데이터 타입 정의를 사용하거나 표준 C 규칙에 따라 작성합니다.

7. 함수 포인터와 메모리 누수


동적으로 할당된 메모리와 결합된 함수 포인터를 사용할 때는 메모리 관리에 주의해야 합니다.
해결 방안: 메모리 해제를 위한 명확한 프로세스를 구현합니다.

모범 사례 요약

  • 함수 포인터 초기화 여부를 항상 확인합니다.
  • 함수 시그니처와 호출 구문을 엄격히 일치시킵니다.
  • NULL 체크 및 오류 처리를 통해 안전성을 확보합니다.
  • 디버깅 메시지를 활용하여 문제를 신속히 파악합니다.

함수 포인터는 강력하지만, 잘못된 사용은 프로그램의 안정성을 위협할 수 있습니다. 신중한 설계와 테스트로 이러한 문제를 예방할 수 있습니다.

함수 포인터를 활용한 고급 응용


함수 포인터는 단순한 함수 호출 이상의 다양한 고급 응용에서 사용됩니다. 플러그인 시스템, 동적 함수 호출, 콜백 관리, 그리고 이벤트 기반 시스템 등 고급 프로그래밍 기법에서 함수 포인터의 강력함을 체감할 수 있습니다.

1. 플러그인 시스템


플러그인 시스템은 함수 포인터를 활용해 동적으로 동작을 변경할 수 있도록 설계됩니다.

예제: 플러그인 기반 데이터 처리 시스템

#include <stdio.h>

// 플러그인 함수 정의
void pluginA() {
    printf("Processing with Plugin A.\n");
}

void pluginB() {
    printf("Processing with Plugin B.\n");
}

// 플러그인 실행 함수
void executePlugin(void (*plugin)()) {
    plugin();
}

int main() {
    // 사용자 선택에 따라 플러그인 변경
    char choice;
    printf("Select plugin (A/B): ");
    scanf(" %c", &choice);

    void (*selectedPlugin)() = NULL;
    if (choice == 'A') {
        selectedPlugin = pluginA;
    } else if (choice == 'B') {
        selectedPlugin = pluginB;
    } else {
        printf("Invalid selection.\n");
        return 1;
    }

    executePlugin(selectedPlugin);

    return 0;
}

2. 동적 함수 호출


동적으로 라이브러리를 로드하고, 함수 포인터를 통해 런타임에 함수를 호출할 수 있습니다. 이는 플러그인 설계나 운영체제 수준의 작업에서 유용합니다.

예제: 동적 함수 로드 (POSIX dlsym 사용)

#include <stdio.h>
#include <dlfcn.h>

int main() {
    void *handle = dlopen("libm.so.6", RTLD_LAZY); // 동적 라이브러리 로드
    if (!handle) {
        fprintf(stderr, "Error: %s\n", dlerror());
        return 1;
    }

    // 함수 포인터로 `cos` 함수 로드
    double (*cosFunc)(double) = (double (*)(double))dlsym(handle, "cos");
    if (!cosFunc) {
        fprintf(stderr, "Error: %s\n", dlerror());
        return 1;
    }

    // 함수 호출
    printf("cos(0.0) = %.2f\n", cosFunc(0.0));

    // 동적 라이브러리 언로드
    dlclose(handle);

    return 0;
}

3. 상태 기반 이벤트 처리


이벤트 기반 시스템에서 함수 포인터를 사용하여 각 상태에 따른 이벤트 핸들러를 구현할 수 있습니다.

예제: 상태 기반 이벤트 관리 시스템

#include <stdio.h>

// 이벤트 핸들러 함수 정의
void onStart() {
    printf("Starting system...\n");
}

void onStop() {
    printf("Stopping system...\n");
}

void onPause() {
    printf("Pausing system...\n");
}

// 이벤트 실행 함수
void executeEvent(void (*eventHandler)()) {
    eventHandler();
}

int main() {
    // 상태에 따른 이벤트 핸들러 설정
    void (*eventHandlers[3])() = {onStart, onStop, onPause};

    // 이벤트 실행
    printf("Executing events:\n");
    for (int i = 0; i < 3; i++) {
        executeEvent(eventHandlers[i]);
    }

    return 0;
}

4. 함수 포인터를 활용한 코루틴 구현


함수 포인터는 C 언어에서 간단한 코루틴을 구현하는 데 사용할 수 있습니다.

예제: 상태 기반 코루틴

#include <stdio.h>

// 상태 정의
void coroutine1() {
    printf("Coroutine 1 executing...\n");
}

void coroutine2() {
    printf("Coroutine 2 executing...\n");
}

int main() {
    void (*coroutines[2])() = {coroutine1, coroutine2};

    // 코루틴 반복 실행
    for (int i = 0; i < 4; i++) {
        coroutines[i % 2]();
    }

    return 0;
}

5. 테스트 더블 및 목(Mock) 객체


테스트 시 함수 포인터를 활용하면 실제 동작을 대체할 목 객체를 쉽게 작성할 수 있습니다.

예제: 목 함수로 함수 동작 테스트

#include <stdio.h>

// 실제 함수
void realFunc() {
    printf("Real function called.\n");
}

// 목 함수
void mockFunc() {
    printf("Mock function called.\n");
}

// 함수 호출
void callFunction(void (*func)()) {
    func();
}

int main() {
    callFunction(realFunc); // 실제 함수 호출
    callFunction(mockFunc); // 목 함수 호출

    return 0;
}

함수 포인터 고급 활용의 장점

  • 동적 확장성: 실행 중 기능 확장 및 변경 가능.
  • 재사용성: 다양한 시나리오에서 동일한 로직 활용 가능.
  • 모듈화: 코드 구조를 체계적으로 설계.
  • 플랫폼 독립성: 다양한 플랫폼에서 유연한 동작 제공.

함수 포인터를 활용한 고급 응용은 코드의 유연성을 극대화하며, 복잡한 프로그램에서도 강력한 동작을 구현할 수 있습니다.

요약


함수 포인터는 C 언어에서 코드의 유연성과 재사용성을 극대화하는 강력한 도구입니다. 이를 활용하면 동적 함수 호출, 상태 관리 시스템, 플러그인 설계, 이벤트 처리, 그리고 객체 지향적인 설계를 구현할 수 있습니다. 적절한 사용 사례와 주의사항을 숙지한다면, 함수 포인터는 다양한 고급 응용에서 큰 가치를 발휘할 수 있습니다.

C 언어
C 언어 모듈화 함수 포인터
목차