c-lang-intermediate

# 포인터와 함수 (Pointer & Function)

## Call by Value vs Call by Reference

C는 기본적으로 **call by value** — 함수에 값이 복사되어 전달됩니다.  
포인터를 사용하면 **call by reference** 효과를 낼 수 있습니다.

```c
// call by value — 원본이 바뀌지 않음
void increment_v(int x) {
    x++;  // 복사본만 변경됨
}

// call by reference — 원본을 직접 수정
void increment_r(int *x) {
    (*x)++;  // 포인터가 가리키는 원본 변경
}

int main(void) {
    int a = 5;

increment_v(a);
    printf("%d\n", a);  // 5 — 변화 없음

increment_r(&a);
    printf("%d\n", a);  // 6 — 원본 변경됨
    return 0;
}
```

---

## 두 값을 교환하는 swap 함수

포인터 인자의 대표적인 예시입니다.

```c
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main(void) {
    int x = 10, y = 20;
    swap(&x, &y);
    printf("x=%d, y=%d\n", x, y);  // x=20, y=10
    return 0;
}
```

---

## 포인터로 여러 값 반환

C 함수는 하나의 반환값만 가질 수 있지만,  
포인터 인자를 통해 **여러 결과를 반환**할 수 있습니다.

```c
void min_max(int *arr, int size, int *min, int *max) {
    *min = *max = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] < *min) *min = arr[i];
        if (arr[i] > *max) *max = arr[i];
    }
}

int main(void) {
    int data[] = {3, 1, 7, 2, 9, 4};
    int mn, mx;

min_max(data, 6, &mn, &mx);
    printf("min=%d, max=%d\n", mn, mx);  // min=1, max=9
    return 0;
}
```

---

## 함수 포인터 (Function Pointer)

함수의 주소를 저장하는 포인터입니다.  
콜백 함수, 전략 패턴 구현에 활용됩니다.

```c
// 선언 형식: 반환타입 (*포인터이름)(매개변수타입, ...)
int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }

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

op = add;
    printf("%d\n", op(3, 4));  // 7

op = mul;
    printf("%d\n", op(3, 4));  // 12
    return 0;
}
```

---

## 함수 포인터를 인자로 전달

```c
void apply(int *arr, int size, int (*transform)(int)) {
    for (int i = 0; i < size; i++) {
        arr[i] = transform(arr[i]);
    }
}

int double_val(int x) { return x * 2; }
int square(int x)     { return x * x; }

int main(void) {
    int data[4] = {1, 2, 3, 4};

apply(data, 4, double_val);
    // data: {2, 4, 6, 8}

apply(data, 4, square);
    // data: {4, 16, 36, 64}
    return 0;
}
```

---

## 배열 포인터를 함수 인자로 전달할 때 주의사항

```c
void fill(int *arr, int size, int value) {
    for (int i = 0; i < size; i++) {
        arr[i] = value;  // 원본 배열이 수정됨
    }
}
```

> 배열을 포인터로 받으면 `sizeof(arr)`가 배열 크기가 아닌 **포인터 크기**를 반환합니다.  
> 반드시 `size`를 별도 인자로 전달하세요.

---

## const 포인터 — 읽기 전용 보호

함수 내부에서 원본을 수정하지 못하도록 `const`를 사용합니다.

```c
void print_array(const int *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
        // arr[i] = 0;  // ❌ 컴파일 오류 — const로 보호됨
    }
}
```

---

## 정리

| 개념 | 핵심 |
|------|------|
| Call by value | 복사본 전달, 원본 불변 |
| Call by reference | 포인터 전달, 원본 수정 가능 |
| 다중 반환 | 포인터 인자로 여러 결과 반환 |
| 함수 포인터 | `반환타입 (*이름)(매개변수)` |
| const 포인터 | 읽기 전용 보호 |

---

포인터와 함수 (Pointer & Function)

// COMMENTS

ON THIS PAGE