[C] 포인터

📌 들어가며

C에서 가장 어렵다고 소문난 포인터 차례다. 실제로 배울 때 헷갈리는 점이 많았지만, 핵심은 하나다. “변수에 값이 아니라 ‘주소’를 담는다.” 이 관점만 잡으면 나머지는 자연스럽게 따라온다.

먼저 기초 개념부터 정리하자.

개념	정의
메모리	연속된 1byte 단위 공간들. 각 byte는 고유한 주소로 접근
주소	데이터가 저장된 위치의 고유값 (타입과 무관)
주소 연산자 &	변수가 저장된 주소값을 반환
참조 연산자 *	포인터가 담은 주소로 찾아가 그 안의 ‘값’을 읽기/쓰기

💡 int는 4byte라서 연속된 1byte × 4칸에 저장된다. 주소는 그중 첫 번째 byte(시작점)를 가리킨다. Windows에서 주소는 4byte(16진수 8자리), Mac/Linux에서는 8byte다.

---

1. 주소 출력해보기 (%p)

%d는 정수 서식, %p는 주소 서식이다. &n으로 변수 n의 주소를 출력해 보자.

int n = ...;
printf("값 = %d\n", n);
printf("주소 = %p\n", &n);   // %p → 16진수 8자리 (4byte)

주소는 16진수(0~F)로 표현된다. (16진수 2자리 = 1byte)

---

2. 포인터 변수 — 값이 아닌 ‘주소’를 담는다

지금까지는 변수에 ‘값’을 담았다. 포인터는 변수에 ‘주소’를 담는다.

int n = 100;
int *p;      // int 타입 포인터 변수 (타입 뒤에 *)
p = &n;      // p에 n의 '주소'를 담음

     n                    p
  ┌───────┐           ┌──────────┐
  │  100  │  ◄────────│ &n(주소) │
  └───────┘           └──────────┘
   0x...A0              p는 n을 가리킨다(pointing)

p와 &n의 값이 같다. p는 &를 안 붙여도 그 자체가 주소를 담은 포인터 변수라서 주소값이 나온다.

참조 연산자 *로 값 읽기

printf("%d\n", *p);   // *p → p가 가리키는 주소로 가서 그 값을 읽음

*p는 p가 담은 주소(=n의 주소)로 찾아가 그 값 100을 출력한다.

참조 연산자로 값 쓰기

*는 읽기뿐 아니라 쓰기도 된다.

int *p2 = &n;   // p2도 n을 가리킴
*p = 500;       // p가 가리키는 곳(n)의 값을 500으로 변경

*p = 500; 후에는 같은 곳을 가리키던 n, *p, *p2가 모두 500이 된다.

⚠️ 포인터에 직접 숫자를 대입하는 건 매우 위험하다. p = 100;이라고 쓰면 참조값이 아니라 주소값 자체가 100이 되어버려 엉뚱한 메모리를 가리킨다.

---

3. 포인터 연산

들어가기 전에 3가지를 짚자.

항목	의미
포인터 변수	주소가 들어감
*포인터	그 주소가 가리키는 값
포인터 타입	그 주소가 가리키는 값의 타입

따라서 포인터에 +, -를 하면 주소값을 증감하는 것이고, 얼마만큼 증감하는지는 ‘포인터 타입’에 따라 다르다.

int*(int 포인터)는 가리키는 값이 4byte라서, +1 하면 주소가 4 증가한다.

n = 555, p = &n일 때 결과를 정리하면:

식	결과
n + 1	556 (단순 정수 덧셈)
p + 1	주소가 +4byte (int라서)
*p + 1	556 (값 555에 +1)
*(p + 1)	쓰레기값 (모르는 주소를 참조)

*(p+1)은 4byte 뒤의 알 수 없는 주소를 참조하므로 쓰레기값이 나온다. 괄호(연산 순서)를 정확히 파악해야 한다.

타입별 +1 증가량
  short* → +2 byte
  int*   → +4 byte
  double* → +8 byte

---

4. 포인터와 배열

★ 비밀 하나: 사실 배열은 포인터의 또 다른 이름이다. 포인터 ‘상수’인 셈이다.

그래서 배열 첨자 연산자 [ ]는 결국 포인터 연산이며, 다음 공식이 성립한다.

arr[n]  ≡  *(arr + n)      ★★★★★

배열 arr = {10, 20, 30}의 주소를 살펴보자. 배열 이름 arr엔 &가 안 붙고, 원소 arr[n]엔 &가 붙는다. 배열 자체는 포인터(주소)이고, 원소는 정수값이기 때문이다.

arr[0]   arr[1]   arr[2]
┌──────┬──────┬──────┐
│  10  │  20  │  30  │
└──────┴──────┴──────┘
0x..A0  0x..A4  0x..A8   ← 주소가 4씩 증가
  ▲
  arr == &arr[0]  (배열 주소 = 첫 원소의 주소 = 시작점)

원소 주소가 4씩 증가하고, arr과 arr[0]의 주소가 같다. 배열의 주소는 곧 첫 원소의 주소(시작점)다.

arr + n은 &arr[n]과 같고, *(arr + n)은 arr[n]과 같다. 공식이 성립함을 확인할 수 있다.

포인터 변수로 배열 자체를 가리키면, 그 포인터가 배열처럼 동작한다.

배열 vs 포인터 변수 — 왜 포인터를 쓸까?

데이터 크기가 다르다. int arr[3]은 sizeof가 4 × 3 = 12byte지만, 그 배열을 가리키는 포인터 p는 sizeof(p)가 4byte다. (모든 포인터 주소 용량은 타입과 무관하게 4byte)

💡 포인터는 메모리에서 다루는 용량이 작아 더 빠른 연산이 가능하다. 그래서 포인터를 쓰면 더 효율적인 작업을 기대할 수 있다.

---

5. 이중 포인터

이중 순환문, 다차원 배열이 있듯 포인터에도 이중 포인터가 있다. 포인터를 가리키는 포인터다.

int num1 = 0;
int *p = &num1;    // p는 num1을 가리킴
int **pp = &p;     // pp는 p를 가리킴 (이중 포인터)

 num1          p            pp
┌─────┐    ┌───────┐    ┌───────┐
│  0  │◄───│ &num1 │◄───│  &p   │
└─────┘    └───────┘    └───────┘
  *p로 1번 참조 →  num1
  **pp로 2번 참조 → p 거쳐 num1

**pp는 p로 갔다가 다시 num1로 가야 하니 두 번 참조하라는 뜻에서 **를 쓴다. (NULL은 아무것도 없는 값으로, 따로 선언 없이 쓸 수 있다.)

num1, *p, **pp가 모두 0으로 동일하게 출력된다.

---

6. 전달 방식에 따른 함수 호출

포인터의 진가는 함수 호출에서 드러난다.

방식	넘기는 것	원본 변화
Call By Value (값에 의한 호출)	값의 복사	❌ 없음
Call By Reference (참조에 의한 호출)	주소(포인터)	✅ 있음

Call By Value

void inc1(int n) { n = n + 1; printf("%d\n", n); }
...
int n = 10;
inc1(n);   // 11 출력
inc1(n);   // 또 11 출력 (원본 n은 그대로 10)

두 번 호출해도 둘 다 11이고, main의 n은 여전히 10이다. 값만 복사했기 때문이다. main의 n과 inc1의 n은 이름만 같은 서로 다른 지역변수다.

Call By Reference

void inc2(int *p) { *p = *p + 1; printf("%d\n", *p); }
...
int n = 10;
inc2(&n);   // n의 '주소'를 넘김

이번엔 호출 후 main의 n 값이 실제로 바뀐다. 값이 아니라 n의 주소를 복사해 참조했기 때문에, 그 주소로 찾아가 원본 n을 직접 조작한 것이다.

---

📝 정리

포인터(pointer)
├─ 핵심     변수에 '값'이 아니라 '주소'를 담는다
├─ 연산자   & (주소 반환) · * (주소로 가서 값 읽기/쓰기)
├─ 연산     p+1 → 타입 크기만큼 주소 증가 (int면 +4)
├─ 배열     arr[n] ≡ *(arr+n),  arr == &arr[0]
├─ 이중포인터  포인터를 가리키는 포인터 (**pp)
└─ 함수호출  Call By Value(복사, 원본 유지) vs Reference(주소, 원본 변경)

개념	한 줄 정의
&	변수의 주소를 반환하는 주소 연산자
*	주소로 찾아가 값을 읽고 쓰는 참조 연산자
arr[n] ≡ *(arr+n)	배열 첨자는 곧 포인터 연산
Call By Reference	주소를 넘겨 원본을 직접 바꾸는 호출 방식

포인터는 결국 “주소를 통해 원본에 직접 접근한다”는 하나의 개념으로 수렴한다. 어렵다고 소문났지만, 이 관점을 잡고 나면 배열·함수·구조체가 모두 연결되는 정말 재미있는 영역이다.