C언어의 포인터 (기초)

Unused의 C언어 포인터 시리즈

포스트	URL
C언어의 포인터 (기초)	https://unused.tistory.com/221
C언어의 포인터 이해: 선언으로서의 *, 연산자로서의 *	https://unused.tistory.com/217
C언어의 배열과 포인터	https://unused.tistory.com/220
C언어의 다중 포인터	https://unused.tistory.com/215

 

---

Credit: https://learningc.org/chapters/chapter06-pointers/what-are-pointers

인트로

프로그래밍을 처음 접하면 “변수(위 그림의 ①)”는 익숙하지만, “포인터(위 그림의 ②)”란 개념은 낯설고 어렵게 느껴집니다.

그런데 사실, 포인터 개념 자체는 어려울 게 없습니다. 포인터는 “메모리의 특정 주소를 저장한 변수”에 불과하거든요. 문법적으로 좀 헷갈리게 되어 있을 뿐입니다 (이번 포인터 시리즈 정리하면서 느낀 개인적인 감상입니다).

포인터가 무엇인지, 포인터를 왜/언제 쓰는지, 포인터를 어떻게 쓰는지. 이번 포스트에서는 포인터의 가장 기본이 되는 개념을 하나씩 차근차근 살펴보겠습니다.

---

1. 포인터란 무엇인가?

• 포인터는 메모리 주소를 담는 변수입니다. 즉, 변수가 저장된 공간의 ‘위치’를 저장하는 변수입니다.
• 일반적인 변수는 값(데이터)을 저장하는 공간입니다.
• 메모리란 흔히 RAM이라 부르는 곳으로, 번호(주소)가 1바이트 단위로 매겨집니다. 가령, 32비트 시스템 기준으로 0x00000000부터 0xFFFFFFFF까지입니다. (관련 문서 참조: CPU 레지스터 ↔ 캐시 ↔ 메모리 ↔ 스토리지의 개념🔗, 메모리 레이아웃🔗, 메모리의 구조🔗)
• 가령, int value = 10;란, “int 타입으로 해석되는 value를 선언, 4바이트의 메모리 공간을 내고, 거기에 10을 저장한다”입니다.
• 한편 int *p = &value;는, “value가 저장된 메모리 주소를, p라는 int 포인터(int *)에 저장한다”는 뜻입니다.

int value = 10;   // value라는 이름으로 4바이트 공간에 10 저장
int *p = &value;  // p라는 이름으로 value의 주소(예: 0xFFB2C4AC) 저장

• p에 든 값은 메모리 주소(예: 0xFFB2C4AC).
• 이 p도 결국 메모리에 저장되는 것이기에, p가 저장된 주소 또한 다른 포인터 변수에 담을 수 있습니다. 그게 바로 다중 포인터입니다. (관련 포스트 참조)

---

2. 포인터는 왜 쓰는가? Call-by-Value vs. Call-by-Reference

포인터는 왜 쓸까요? C에서 모든 함수 인자는 복사되어 넘어가기 때문입니다. 원본이 아닌 복사본이기에, 함수에 인자를 전달하는 방식은 크게 두 가지로 나뉩니다. 위 이미지 좌측이 바로 call-by-reference, 우측이 call-by-value입니다. 자세한 문법에 대해서는 아래 설명을 드리므로 현시점에서는 포인터를 쓰는 이유를 중점적으로 파악해주시면 좋겠습니다.

2.1. Call-by-Value (값을 전달)

void foo(int x) {
    x = 999;
}

int main() {
    int a = 123;
    foo(a);
    printf("%d\n", a);  // 123
}

• a의 값이 함수에 복사되어 들어갑니다.
• 즉, main()의 int a와 foo()의 int x는 서로 별개의 물건입니다. 단지 같은 값을 가지고 있을 뿐입니다.
• foo()는 123을 복사받은 것이고, 이를 foo() 안에서 x = 999;라고 바꿔도, main()의 a에는 영향이 없습니다.
• 요컨대 원본은 그대로입니다.

---

2.2. Call-by-Reference (값이 위치한 주소를 전달)

void foo(int *x) {
    *x = 999;
}

int main() {
    int a = 123;
    foo(&a);
    printf("%d\n", a);  // 999
}

• a의 주소값(&a)이 함수에 복사되어 들어갑니다. 이걸 받은 함수에서는 이를 역참조 연산자를 통해 접근할 수 있습니다.
• 복사 자체는 call-by-value와 같지만, 여기서 복사되는 것은 주소값입니다. 
• 즉, foo() 안에서 *x = 999;는, main()의 a라는 변수가 위치한 메모리 주소에 접근해서 원본의 a를 수정합니다.
• 이 결과로, 원본이 바뀝니다.

---

2.3. 정리하기

• Call-by-Value
  • 숫자 등 단순한 데이터의 빠른 전달
  • 값을 읽기만 할 뿐 원본을 변경할 필요는 없을 때
• Call-by-Reference
  • 문자열, 배열, 구조체를 비롯한 큰 데이터의 효율적인 전달
  • 원본을 변경해야 할 때

결국 이 차이입니다. foo(12345);와 foo(0xABCDABCD);. 피호출 함수의 입장에서 보면, 전자의 경우 12345라는 숫자를 전달받았기에 그걸 자기가 54321로 고치든 0으로 고치든 그 함수가 끝나는 순간 아무런 의미가 없어집니다. 하지만 후자의 경우 0xABCDABCD라는 주소를 전달받았기에 피호출 함수가 0xABCDABCD라는 주소로 직접 가서 값을 고칠 수 있는 것입니다.

---

2.4. 사용 예시: swap 함수

Call-by-Value로는 작동 안 함

void swap(int a, int b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int x = 10, y = 20;
swap(x, y); // 해당 함수가 종료되면 여기의 x, y는 그대로

Call-by-Reference로는 작동함

void swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

int x = 10, y = 20;
swap(&x, &y); // 해당 함수 나오고 나서도 x, y 값이 바뀐 채로 유지

---

3. 선언/초기화 문법

문법은 아래와 같습니다.

type *이름;    // 선언만 했음: 쓰레기 주소를 가리킬 수 있으니 반드시 초기화해야 함.
type *이름 = NULL;       // 초기화 1: NULL 포인터로 시작
type *이름 = &변수;      // 초기화 2: 실제 변수 주소를 대입

• type *는 “type 형 변수의 주소를 저장할 포인터”라는 뜻. 예시) int *, char *, float *, void *, ...
• 반드시 초기화해야 예기치 않은 메모리 접근을 방지할 수 있습니다.

사용 예시는 아래와 같습니다.

int myValue = 12345;

int *myPtr1;    // 선언만 했음: 쓰레기 주소를 가리킬 수 있으니 반드시 초기화해야 함!
int *myPtr2 = NULL;          // 초기화 1: NULL 포인터로 시작
int *myPtr3 = &myValue;      // 초기화 2: 실제 변수 주소를 대입

---

4. 역참조 연산자 *

• 주의! 위 '선언/초기화 문법'의 *와는 다른 역할입니다. 관련 포스트를 꼭 읽어주세요.
• *포인터는 “포인터가 가리키는 메모리 위치의 값을 읽거나 쓴다”는 의미입니다.
• 읽기: int y = *p;
• 쓰기: *p = 99;

int value = 10;
int *p = &value;

printf("before: %d\n", value);  // 10
*p = 20;                         // value의 메모리에 20 저장
printf(" after: %d\n", value);  // 20

---

5. 주소 연산자 &

• &변수는 “변수가 저장된 메모리의 주소”를 가져옵니다.
• &value → value가 메모리에 놓여 있는 위치(예: 0xFFB2C4AC)

int x = 42;
printf("x의 주소: %p\n", &x);

---

6. 포인터 산술 연산

• 같은 +, -를 쓰더라도 포인터는 다릅니다! 포인터는 가리키는 타입의 크기만큼 이동합니다.
  • p가 포인터일 때, p+1은 sizeof(type) 바이트만큼 넘어감
  • 예시 1: int *p; p+1은 p에서 4바이트를 넘어간 주소 (32비트 int 기준)
  • 예시 2: void *p; p+1은 p에서 1바이트 넘어간 주소
  • 예시 3: int (*p)[7]; p+1은 p에서 int[7] (즉, 7 × sizeof(int) = 28바이트)를 넘어간 주소
  • 예시 4: int (*p)[7][5]; p+1은 p에서 int[7][5] (즉, 7 × 5 × sizeof(int) = 140 바이트)를 넘어간 주소

int arr[3] = {100, 200, 300};
int *p = arr;      // &arr[0]
printf("%d\n", *p);    // arr[0] → 100
p = p + 1;
printf("%d\n", *p);    // arr[1] → 200

---

7. NULL 포인터와 안전한 사용

• NULL 포인터: NULL 또는 0으로 초기화된 포인터
• 역참조 전에 반드시 NULL 체크!

int *p = NULL;
if (p != NULL) {
    printf("%d\n", *p);
} else {
    puts("포인터가 유효하지 않습니다!");
}

---

8. 포인터와 배열의 관계

• 관련 포스트를 참조하실 수 있습니다. 배열명은 곧 첫 번째 원소의 주소로 해석됩니다.
• int arr[5]; → arr는 &arr[0]와 동일한 값
• 배열 탐색: arr[i]는 *(arr + i)와 동일

char str[] = "HELLO";
char *p = str;      // &str[0]
for (int i = 0; p[i] != '\0'; i++) {
    putchar(*(p + i));  // p[i]
}

---

요약 & 결론

1. 포인터 = 메모리 주소를 담는 변수
2. 포인터를 왜 쓰냐고? 함수 인자 전달 방식 때문
   • call-by-value: 값 복사 → 원본 수정 불가
   • call-by-reference: 주소값을 복사 → 포인터를 통해 원본의 주소로 접근, 고로 원본을 수정 가능
3. 선언: type *p;
4. 주소 연산자 &: 변수의 메모리 주소를 구함
5. 역참조 *: 가리키는 위치의 값 읽기/쓰기
6. 포인터 산술: 타입 크기만큼 이동 (p + 1)
7. 배열 이름은 포인터처럼 동작 (arr은 사실상 &arr[0]처럼 사용 가능 ― 관련 포스트 참조)
8. 항상 초기화 및 NULL 체크로 안전하게 사용하기

포인터는 어렵지 않습니다. 그 문법이 좀 헷갈리지만요.

포인터는 처음엔 복잡해 보여도, 결국 “메모리상의 주소를 변수에 담고, 그 주소의 값을 읽거나 쓰기 위한 도구”라는 점만 기억하면 됩니다. 이 개념을 탄탄히 다지고 나면, 함수간 메모리 공유, 동적 할당, 자료구조 등 C언어로 무엇을 짜더라도 두렵지 않습니다.