c-lang-intermediate

# 배열과 포인터 (Pointer & Array)

## 배열 이름은 포인터다

C에서 배열 이름은 **첫 번째 원소의 주소**와 동일합니다.

```c
int arr[5] = {10, 20, 30, 40, 50};

printf("%p\n", arr);      // 배열의 시작 주소
printf("%p\n", &arr[0]);  // 동일한 주소
```

> `arr == &arr[0]` 은 항상 참입니다.

---

## 포인터로 배열 접근

```c
int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;  // &arr[0]과 동일

printf("%d\n", p[0]);   // 10
printf("%d\n", p[2]);   // 30
printf("%d\n", *(p+3)); // 40
```

| 표현식 | 동일한 표현 | 값 |
|--------|------------|-----|
| `arr[i]` | `*(arr + i)` | i번째 원소 |
| `p[i]` | `*(p + i)` | i번째 원소 |
| `&arr[i]` | `arr + i` | i번째 원소의 주소 |

---

## 포인터 산술 (Pointer Arithmetic)

포인터에 정수를 더하면 **타입 크기만큼** 주소가 이동합니다.

```c
int arr[3] = {1, 2, 3};
int *p = arr;

p++;              // 다음 int로 이동 (+4바이트)
printf("%d\n", *p); // 2

p += 1;           // 또 다음으로
printf("%d\n", *p); // 3
```

```
주소:  1000   1004   1008
값:     1      2      3
        ^p  →  ^p  →  ^p
```

> 포인터 산술은 **같은 배열 내**에서만 유효합니다.

---

## 포인터 간 뺄셈

같은 배열을 가리키는 두 포인터의 차는 **원소 개수**를 반환합니다.

```c
int arr[5] = {10, 20, 30, 40, 50};
int *p1 = &arr[1];
int *p2 = &arr[4];

ptrdiff_t diff = p2 - p1;  // 3 (원소 3개 차이)
printf("%td\n", diff);
```

---

## 배열을 함수에 전달

배열을 함수에 넘기면 실제로는 **포인터가 전달**됩니다(값 복사 없음).

```c
void print_array(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main(void) {
    int data[4] = {1, 2, 3, 4};
    print_array(data, 4);  // data == &data[0]
    return 0;
}
```

> `void print_array(int arr[], int size)` 와 위 코드는 **완전히 동일**합니다.

---

## 배열과 포인터의 차이점

포인터와 배열은 비슷해 보이지만 차이가 있습니다.

```c
int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;

sizeof(arr);  // 20 (5 * 4바이트) — 전체 배열 크기
sizeof(p);    // 8  (포인터 크기) — 주소 하나의 크기

arr = p;      // ❌ 오류 — 배열 이름은 상수 포인터, 변경 불가
p = arr;      // ✅ 가능
```

---

## 정리

| 표현 | 의미 |
|------|------|
| `arr` | 첫 번째 원소의 주소 |
| `arr[i]` | `*(arr + i)` |
| `p++` | 타입 크기만큼 주소 증가 |
| `p2 - p1` | 두 포인터 사이의 원소 수 |
| 함수 인자 전달 | 포인터로 전달 (decay) |

---

배열과 포인터 (Pointer & Array)

// COMMENTS

ON THIS PAGE