MENU
  1. ホーム
  2. C 언어
  3. C에서 함수 포인터로 간접 접근 제어하는 방법

C에서 함수 포인터로 간접 접근 제어하는 방법

C 언어

C 언어에서 함수 포인터를 활용하면 코드의 유연성과 모듈화가 높아지며, 특정 기능에 대한 접근을 보다 체계적으로 관리할 수 있습니다. 본 기사에서는 함수 포인터가 작동하는 원리를 간단히 살펴보고, 이를 활용해 간접적인 접근과 권한 제어를 수행하는 기법을 소개합니다. 보안 관점에서도 큰 이점이 있는 함수 포인터의 활용 방안을 이해함으로써, 코드 재사용성과 유지보수성을 동시에 높일 수 있는 방법을 모색해 보겠습니다.

목차

함수 포인터 기본 원리


함수 포인터(Function Pointer)는 함수의 메모리 주소를 변수에 저장해 두고, 이를 통해 함수를 간접 호출할 수 있도록 해주는 기능입니다. 일반 포인터가 데이터의 주소를 저장하듯, 함수 포인터는 실행 가능한 함수의 시작 주소를 가리킵니다.

메모리 관점에서의 특징

  • 코드 세그먼트 접근: 함수 포인터는 코드 세그먼트(프로그램 명령어가 저장된 영역)의 특정 위치를 가리키며, 이를 통해 동일한 함수를 여러 곳에서 자유롭게 호출할 수 있습니다.
  • 동적 할당 가능: 프로그램 실행 중에도 함수 포인터에 다른 함수 주소를 할당함으로써, 런타임에 호출 함수를 유연하게 변경할 수 있습니다.
  • 안전한 사용 주의: 잘못된 함수 포인터 연산(예: 주소 변조)으로 인해 예기치 못한 함수를 실행하거나 충돌이 발생할 수 있으므로, 함수 시그니처와 타입을 일치시켜 안전하게 사용해야 합니다.

기본 선언 형식

// 반환값이 int이고, 파라미터로 int 두 개를 받는 함수를 가리키는 포인터 선언
int (*funcPtr)(int, int);


위 예시에서 (*funcPtr)(int, int)는 “int형 두 개의 인자를 받고 int를 반환하는 함수”의 주소를 저장하는 포인터를 의미합니다.

함수 포인터를 이해함으로써, 여러 함수를 동적으로 선택하거나 호출 구문을 단순화하는 등 다양한 상황에서 유연하고 효율적으로 코드를 작성할 수 있습니다.

함수 포인터 선언 및 사용 예시


함수 포인터를 실제로 선언하고 사용하는 예시 코드를 통해 그 동작 방식을 자세히 살펴보겠습니다.

예제 코드

#include <stdio.h>

// 간단한 연산 함수들
int add(int a, int b) {
    return a + b;
}

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

int main() {
    // 'int(int, int)' 형태의 함수를 가리키는 함수 포인터 선언
    int (*funcPtr)(int, int);

    // 함수 포인터에 'add' 함수를 대입
    funcPtr = add;
    printf("add(10, 5) 결과: %d\n", funcPtr(10, 5));

    // 함수 포인터를 'sub' 함수로 변경
    funcPtr = sub;
    printf("sub(10, 5) 결과: %d\n", funcPtr(10, 5));

    return 0;
}

코드 분석

  • int (*funcPtr)(int, int);는 두 개의 int 파라미터를 받고 int를 반환하는 함수를 가리키는 포인터입니다.
  • funcPtr = add;와 같이, 원하는 함수의 이름을 할당해 주면 그 함수를 간접적으로 호출할 수 있습니다.
  • funcPtr(10, 5)를 통해 실제 함수를 호출하는 과정에서, 코드 측면에서는 add(10, 5) 또는 sub(10, 5)를 실행한 것과 동일한 결과를 얻습니다.
  • 이러한 방식으로 함수 포인터를 사용하면, 런타임에 호출할 함수를 유연하게 변경하거나 여러 함수 중 하나를 선택적으로 호출할 수 있어 코드 구조가 보다 모듈화됩니다.

함수 포인터를 통한 인덱싱 기법


함수 포인터 배열을 활용하면, 여러 함수를 하나의 구조로 묶어 간단히 접근할 수 있습니다. 예를 들어, 여러 연산 함수를 인덱스로 구분해 두고, 필요에 따라 해당 인덱스에 맞는 함수를 호출하는 식으로 사용할 수 있습니다.

함수 포인터 배열을 이용한 예제

#include <stdio.h>

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

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

int mul(int a, int b) {
    return a * b;
}

int myDiv(int a, int b) {
    // 0 나누기 방지
    return b != 0 ? a / b : 0;
}

int main() {
    // 'int(int, int)' 형태 함수를 가리키는 포인터 배열
    int (*funcArr[4])(int, int) = { add, sub, mul, myDiv };

    int x = 20, y = 5;

    // 인덱스를 통해 함수 선택
    printf("add: %d\n", funcArr[0](x, y));  // add(20, 5)
    printf("sub: %d\n", funcArr[1](x, y));  // sub(20, 5)
    printf("mul: %d\n", funcArr[2](x, y));  // mul(20, 5)
    printf("div: %d\n", funcArr[3](x, y));  // myDiv(20, 5)

    return 0;
}

코드 활용 방식


함수 포인터 배열을 선언해 두면, 별도의 조건문 없이도 인덱스 번호를 통해 직접 함수를 선택할 수 있습니다. 특정 연산 함수를 호출해야 할 때마다 funcArr[i](x, y) 형태로 호출할 수 있으므로, 코드 유지보수가 간단해지고 구조적인 접근이 가능합니다.

장점


함수 포인터 배열을 사용하면 다음과 같은 이점이 있습니다.

  • 코드를 간결하게 유지: 여러 if-else나 switch 구문 없이도, 배열 인덱스를 통해 곧바로 함수를 호출합니다.
  • 재사용성 증대: 새로운 함수를 추가하거나 교체할 때, 배열에 함수를 추가하거나 변경하는 방식만으로 코드 확장이 가능합니다.
  • 가독성 향상: 동일한 인터페이스(매개변수와 반환 형식)를 가진 여러 함수를 한 번에 관리하기 쉬워, 전반적인 코드 이해가 빨라집니다.

접근 제어를 위한 함수 포인터 활용


보안이 중요한 환경에서는 특정 기능을 함부로 호출할 수 없도록 접근 권한을 제한해야 합니다. 함수 포인터를 통해 이러한 접근 제어 로직을 간접적으로 관리하면, 각 권한 수준에 따라 호출 가능한 함수를 제어하고 코드 중복을 최소화할 수 있습니다.

권한 기반 함수 선택


예를 들어, 사용자 권한에 따라 사용할 수 있는 함수 포인터 배열을 달리 구성하거나, 접근 권한이 낮은 사용자에겐 제한된 함수 포인터만 제공하는 방식으로 보안을 강화할 수 있습니다. 아래는 개념을 단순화한 예시입니다.

#include <stdio.h>

// 예시: 관리자(admin) 권한과 일반 권한(user)
typedef enum {
    USER,
    ADMIN
} Role;

int readData() {
    // 데이터 조회 기능
    printf("Data read.\n");
    return 0;
}

int writeData() {
    // 데이터 작성 기능
    printf("Data written.\n");
    return 0;
}

int main() {
    // 'int(void)' 형태 함수를 가리키는 포인터
    int (*userFuncs[1])() = { readData };
    int (*adminFuncs[2])() = { readData, writeData };

    Role currentRole = ADMIN; // 가정: 현재 권한

    // 권한에 따라 호출 가능한 함수 포인터 배열 사용
    if (currentRole == USER) {
        // 일반 권한은 조회 기능만 허용
        userFuncs[0]();
    } else if (currentRole == ADMIN) {
        // 관리자 권한은 조회, 쓰기 모두 허용
        adminFuncs[0](); // readData
        adminFuncs[1](); // writeData
    }

    return 0;
}

모듈화와 유지보수성

  • 별도 로직 분리: 접근 권한 관리는 함수 포인터 배열과 권한 정보를 매핑하는 부분에서 처리됩니다. 따라서 주 기능 코드와 보안 로직이 분리되어, 유지보수가 용이합니다.
  • 조건문 최소화: 여러 권한별 기능을 if-else 혹은 switch-case 구문으로 분기하기보다, 권한에 맞는 함수 포인터 배열만 선택하도록 구조화하면 코드가 단순해집니다.

함수 포인터를 통한 접근 제어 방식은 프로젝트 규모가 커질수록 그 효율성이 증대됩니다. 권한별로 다른 기능을 실행해야 할 때, 각 권한에 적합한 함수 목록만 노출하면 되기 때문에 사용자 경험과 보안성을 모두 향상시킬 수 있습니다.

실습 예시와 유의점


함수 포인터를 실무에서 효과적으로 활용하기 위해서는 코드 구조뿐 아니라 안전성에도 유의해야 합니다. 아래 예제에서는 콜백(Callback) 형태로 함수 포인터를 등록하고 실행하는 방식을 살펴보며, 잘못된 함수 포인터 사용으로 인한 문제를 방지하는 방법을 함께 살펴봅니다.

함수 포인터 콜백 등록 예시

#include <stdio.h>

// 콜백으로 호출할 함수 포인터 타입 정의
typedef void (*CallbackFunc)(const char* message);

// 콜백으로 사용할 함수들
void printMessage(const char* message) {
    printf("[printMessage] %s\n", message);
}

void logMessage(const char* message) {
    // 실제 환경에서는 파일 입출력 등을 수행
    printf("[logMessage] %s\n", message);
}

// 콜백 함수를 등록하고 실행하는 함수
void runCallback(CallbackFunc callback) {
    if (callback) {
        callback("Hello from Callback!");
    } else {
        printf("콜백 함수가 등록되지 않았습니다.\n");
    }
}

int main() {
    // 1) printMessage 함수 등록 후 실행
    runCallback(printMessage);

    // 2) logMessage 함수 등록 후 실행
    runCallback(logMessage);

    // 3) 등록 없이 실행 (NULL 포인터)
    runCallback(NULL);

    return 0;
}

위 코드에서는 CallbackFunc라는 함수를 가리키는 타입을 typedef로 정의하여, 가독성과 유지보수를 용이하게 했습니다. runCallback 함수 내에서 callback이 유효한지 확인한 뒤에 호출하도록 작성해, 잘못된 포인터 참조를 최소화합니다.

시그니처(Signature) 주의


함수 포인터의 파라미터와 반환형은 실제로 호출할 함수와 정확히 일치해야 합니다. 예컨대 void (*cb)(int) 형태의 포인터에 void foo(double) 함수를 연결하면, 컴파일러가 경고를 하거나 심한 경우 런타임 오류가 발생할 수 있습니다.

메모리 라이프사이클

  • 스택 혹은 지역 변수가 범위를 벗어나면 해당 함수의 주소를 더 이상 유효하게 사용할 수 없습니다.
  • 동적으로 할당한 객체 혹은 라이브러리가 언로드(unload)된 뒤에도 함수 포인터를 보관하면, 잘못된 주소를 참조하게 됩니다.

디버깅 시 고려 사항

  • 함수 포인터가 가리키는 주소를 확인할 때는 디버거를 활용하면 어느 함수가 연결되어 있는지 쉽게 파악할 수 있습니다.
  • 함수를 호출하는 과정에서 프로그램이 비정상 종료된다면, 시그니처 불일치나 해제된 메모리에 대한 포인터 참조 여부를 우선 점검해 봐야 합니다.

함수 포인터는 코드의 구조를 유연하게 만들지만, 타입 불일치나 잘못된 주소 참조로 인해 오류가 발생하기 쉽다는 점을 반드시 기억해야 합니다. 이러한 위험 요소를 인지하고 코드를 작성하면, 다양한 상황에서 안정적이며 모듈화된 코드를 구현할 수 있습니다.

예제 문제 풀이


함수 포인터 개념을 확실히 이해하기 위해 간단한 문제를 풀어 보겠습니다.

문제

  1. 다음과 같은 연산 함수를 작성합니다.
  • 덧셈: add(int, int)
  • 뺄셈: sub(int, int)
  • 곱셈: mul(int, int)
  1. 사용자로부터 연산 기호(+, -, *)와 두 정수 값을 입력받고, 함수 포인터를 이용해 적절한 함수를 호출하도록 구현하세요.
  2. 입력된 연산 기호가 위에서 정의한 연산 함수를 지원하지 않는 경우, Unsupported operation!을 출력하세요.

예시 코드 풀이

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

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

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

int mul(int a, int b) {
    return a * b;
}

int main() {
    char op;
    int x, y;

    // 사용자 입력 받기
    printf("연산을 입력하세요 (+, -, *): ");
    scanf(" %c", &op);
    printf("정수 두 개를 입력하세요: ");
    scanf("%d %d", &x, &y);

    // 함수 포인터 선언
    int (*funcPtr)(int, int) = NULL;

    // 연산 기호에 따른 함수 포인터 할당
    switch(op) {
        case '+':
            funcPtr = add;
            break;
        case '-':
            funcPtr = sub;
            break;
        case '*':
            funcPtr = mul;
            break;
        default:
            // 지원하지 않는 연산 기호일 경우
            printf("Unsupported operation!\n");
            return 0;
    }

    // 함수 포인터를 통한 연산 및 출력
    int result = funcPtr(x, y);
    printf("결과: %d\n", result);

    return 0;
}

해설

  • char op으로 사용자로부터 연산 기호를 입력받습니다.
  • int (*funcPtr)(int, int) = NULL;로 선언된 함수 포인터는 add, sub, mul 중 하나를 가리키도록 설정됩니다.
  • 지원하지 않는 연산 기호가 들어오면 default 분기에서 바로 메시지를 출력하고 종료합니다.
  • funcPtr(x, y);를 통해 해당 포인터가 가리키는 함수를 호출하고, 결과를 출력합니다.

이 문제를 통해 함수 포인터를 활용한 동적 함수 호출 방식을 익힐 수 있습니다. 또한, 연산을 추가로 정의해야 하는 경우에 단순히 함수 하나를 작성하고 switch 구문에 포인터 할당 로직만 더하면 되므로, 코드가 확장에 유연하다는 장점도 확인할 수 있습니다.

요약


본 기사에서는 C 언어에서 함수 포인터를 이용한 접근 제어 기법과 응용 사례를 살펴봤습니다. 함수 포인터 배열, 콜백 방식, 보안 관점의 활용까지 다루면서, 유연하고 모듈화된 코드를 작성하는 핵심 원리를 확인했습니다. 시그니처와 메모리 안전성에 주의해 올바로 사용한다면, 프로젝트 전반의 유지보수성과 확장성을 크게 높일 수 있습니다.

C 언어
C언어 접근제어 함수포인터
목차