보이드 포인터, 함수 포인터 복습

• 보이드 포인터

 

    void *ptr;
    int tmp = 10;
    ptr = &tmp;
    printf("%d", *(int *)ptr);

보이드 포인터로 선언하고 

보이드포인터  = 특정 자료형 으로 대입한 후

(특정 자료형 *) 형태로 가져와서 쓸 수 있다

 

#include <stdio.h>

void print_first_element(void *arr, char type) {
    if (type == 'i') {
        printf("첫 번째 정수형 요소: %d\n", *((int*)arr));
    } else if (type == 'f') {
        printf("첫 번째 실수형 요소: %f\n", *((float*)arr));
    } else {
        printf("알 수 없는 타입입니다.\n");
    }
}

int main() {
    int int_arr[] = {10, 20, 30};
    float float_arr[] = {1.1f, 2.2f, 3.3f};

    print_first_element(int_arr, 'i');
    print_first_element(float_arr, 'f');

    return 0;
}

 

메서드나 배열에서 받아올 때도 특정 자료형 요소로 명시적 캐스팅해서 가져올 수 있다

 

#include <stdio.h>
#include <string.h>

typedef struct {
    char name[50];
    int age;
} Student;

void print_student_info(void *student_ptr) {
    Student *student = (Student*)student_ptr;
    printf("이름: %s\n", student->name);
    printf("나이: %d\n", student->age);
}

int main() {
    Student s1;
    strcpy(s1.name, "홍길동");
    s1.age = 20;

    print_student_info(&s1);

    return 0;
}

 

사용자가 정의한 구조체 포인터로도 받아서 변환해서 사용 가능하다

 

• 함수 포인터

 

#include <stdio.h>

// 두 정수를 더하는 함수
int add(int a, int b) {
    return a + b;
}

// 두 정수를 곱하는 함수
int multiply(int a, int b) {
    return a * b;
}

// 연산을 수행하는 함수
void perform_operation(int (*operation)(int, int), int x, int y) {
    printf("결과: %d\n", operation(x, y));
}

int main() {
    int choice, x, y;
    int (*func_ptr)(int, int);

    printf("두 정수를 입력하세요: ");
    scanf("%d %d", &x, &y);

    printf("1. 덧셈\n2. 곱셈\n선택하세요: ");
    scanf("%d", &choice);

    if (choice == 1) {
        func_ptr = add;
    } else if (choice == 2) {
        func_ptr = multiply;
    } else {
        printf("잘못된 선택입니다.\n");
        return 1;
    }

    perform_operation(func_ptr, x, y);

    return 0;
}

 

 

!

보이드 포인터에 진행할 연산을 저장해두고 다시 그 보이드 포인터를 특정 자료형 함수포인터에 대입해서 연산하는 코드

#include <stdio.h>

// 두 정수를 더하는 함수
int add(int a, int b) {
    return a + b;
}

// 두 정수를 곱하는 함수
int multiply(int a, int b) {
    return a * b;
}

// 연산을 수행하는 함수
void perform_operation(void* func, int x, int y) {
    int (*operation)(int, int)= (int (*)(int, int)) func;
    printf("결과: %d\n", operation(x, y));
}

int main() {
    int choice, x, y;
    void *func_ptr;
    int (*func)(int, int);

    printf("두 정수를 입력하세요: ");
    scanf("%d %d", &x, &y);

    printf("1. 덧셈\n2. 곱셈\n선택하세요: ");
    scanf("%d", &choice);

    if (choice == 1) {
        func_ptr = (void *)add;
    } else if (choice == 2) {
        func_ptr = (void *)multiply;
    } else {
        printf("잘못된 선택입니다.\n");
        return 1;
    }

    func = (int (*)(int, int))func_ptr;
    printf("%d",func(x,y));

    return 0;
}

 

연산을 받아들일 void 포인터를 만들어 둔 후

특정 연산을 (void *)메서드 형태로 보이드 포인터로 캐스팅해서 저장하고

보이드 포인터를 함수 포인터 형태로 다시 형변환해서

값을 가져오게 코드를 작성했다

 

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

// 사칙연산 함수들 선언
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) {
    if (b == 0) {
        fprintf(stderr, "Division by zero\n");
        exit(EXIT_FAILURE);
    }
    return a / b;
}

// 함수 포인터 타입 정의
typedef int (*Operation)(int, int);

// 연산자를 받아 적절한 함수 포인터를 반환하는 함수
Operation getOperation(char op) {
    switch (op) {
        case '+':
            return add;
        case '-':
            return subtract;
        case '*':
            return multiply;
        case '/':
            return divide;
        default:
            fprintf(stderr, "Invalid operator\n");
            exit(EXIT_FAILURE);
    }
}

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

    // 사용자로부터 입력 받기
    printf("Enter first integer: ");
    scanf("%d", &x);
    printf("Enter an operator (+, -, *, /): ");
    scanf(" %c", &op);  // 앞에 공백을 넣어 개행 문자를 무시합니다.
    printf("Enter second integer: ");
    scanf("%d", &y);

    // 적절한 연산 함수 선택
    Operation operation = add;

    // 함수 포인터를 사용하여 연산 수행
    int result = operation(x, y);
    printf("Result: %d\n", result);

    return 0;
}

 

 

보이드 -> 함수포인터

함수 -> 보이드 -> 함수 형태로도 사용 가능하다

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

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

int oper(void * func, int x, int y){
    int (*op)(int, int) = (int(*)(int, int))func;
    return op(x,y);
}

int main() {
    int x, y;
    char op;
    void (* func_ptr)(int, int);
    scanf("%d %d %c", &x, &y, &op);
    if(op == '+') func_ptr = (void *) add;
    else if(op == '*') func_ptr = (void *) mul;
    printf("%d\n", oper(func_ptr, x, y));
    int (*pFunction)(int, int) = (int (*)(int, int)) func_ptr;
    printf("%d\n", pFunction(x, y));
}