C언어의 다중 포인터

IT/컴퓨팅적 사고

C언어의 다중 포인터

Unused 2025. 4. 13. 01:08

Unused의 C언어 포인터 시리즈

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

C언어에서 포인터는 변수의 메모리 주소를 직접 다루는 중요한 개념입니다. 그리고 포인터를 다루다 보면 별이 2개 이상, 즉 다중 포인터를 써야만 하는 경우가 있습니다. 예를 들어, 다차원 배열을 다루거나, 함수에서 포인터 자체를 수정할 때 다중 포인터(pointer to pointer)가 필요합니다.

이번 포스트에서는 포인터(*) 및 주소값 연산자(&)에 대한 간략한 복습과 함께, 다중 포인터의 개념을 이해하고, 이를 활용하는 방법을 예제와 함께 설명해보고자 합니다. 또한 별이 무작정 늘어나는 예시 "별이 다섯 개"와 이를 막을 방법에 대해서도 한번 알아보겠습니다.

0. 단일 포인터 복습

먼저 단일 포인터를 복습해봅시다. 단일 포인터는 특정 변수의 주소값을 저장하는 변수입니다.

int value = 42;
int *p = &value;  // 'p'는 'value'의 주소값을 저장하는 포인터

이는 뭉뚱그리면 아래와 다를 바가 없습니다. (value의 주소값은 0x12341234임을 가정)

int value = 42;
int *p = 0x12341234;

도식화하면 아래와 같습니다.

+---------------------------------------------------------+ 0xFFFFFFFF
|                                                         | 
|                      (... 생략 ...)                      | 
|                                                         | 
+---------------------------------------------------------+ 
| int *p = &value   --> 0x12341234                        | ← p
+---------------------------------------------------------+ (그럼 얘의 주소값은?)
|                                                         | 
|                      (... 생략 ...)                      | 
|                                                         | 
+---------------------------------------------------------+
| int value = 42                                          | ← value
+---------------------------------------------------------+ 0x12341234
|                                                         | 
|                      (... 생략 ...)                      | 
|                                                         | 
+---------------------------------------------------------+ 0x00000000

위 예제에서 p는 value의 메모리 주소를 저장하는 포인터이며, &value는 곧 value의 메모리 주소를 가져오는 연산자입니다. 이렇게, *p를 사용하면 value의 값을 간접적으로 참조할 수 있습니다. 이러한 인자를 함수로 넘길 때 callee1(value), 즉, callee1(42) 같은 식으로 쓰면 그게 call-by-value입니다. callee1(&value), 즉, callee1(0x12341234)처럼 쓰면 그게 바로 call-by-reference입니다.

그런데, 생각해보면, *p 또한 하나의 변수입니다. 주소값을 담는 변수.

그렇다면... 얘 역시 메모리 어딘가에 보관되어 있는 거겠죠? 이 변수의 주소값을 담기 위한 게 아래의 **pp, 즉, 다중 포인터 되시겠습니다.

int value = 42;
int *p = &value;  // 'p'는 'value'의 주소를 저장하는 포인터
int **pp = &p;  // 'pp'는 'p'의 주소를 저장하는 포인터

1. 다중 포인터

다중 포인터는 포인터를 가리키는 포인터로, 즉, 포인터의 주소를 담는 포인터입니다. 아래 간단한 예시를 보시겠습니다.

#include <stdio.h>

int main() {
    int num = 302;  
    int *ptr1 = &num; 
    int **ptr2 = &ptr1; 
    int ***ptr3 = &ptr2;

    printf("num (original): %d\n", num); 

    printf("ptr1: 0x%08X\n", ptr1);
    printf("*ptr1: %d\n", *ptr1); 

    printf("ptr2: 0x%08X\n", ptr2);
    printf("*ptr2: 0x%08X\n", *ptr2);
    printf("**ptr2: %d\n", **ptr2); 

    printf("ptr3: 0x%08X\n", ptr3); 
    printf("*ptr3: 0x%08X\n", *ptr3);
    printf("**ptr3: 0x%08X\n", **ptr3); 
    printf("***ptr3: %d\n", ***ptr3); 

    return 0;
}

이를 도식화하면 아래와 같습니다.

+---------------------------------------------------------+ 0xFFFFFFFF
|                                                         |  
|                     (... 생략 ...)                       | 
|                                                         | 
+---------------------------------------------------------+ 
| int ***ptr3 = &ptr2   --> 0xFFFFDA48                    | ← ptr3
+---------------------------------------------------------+
| int **ptr2 = &ptr     --> 0xFFFFDA40                    | ← ptr2
+---------------------------------------------------------+ 0xFFFFDA48
| int *ptr = &num       --> 0xFFFFDA3C                    | ← ptr
+---------------------------------------------------------+ 0xFFFFDA40
| int num = 302                                           | ← num 
+---------------------------------------------------------+ 0xFFFFDA3C
      ↑            ↑              ↑
      |            |              |
   *ptr         **ptr2        ***ptr3
  (=302)        (=302)         (=302)

다중 포인터는 보통 이러한 경우 사용됩니다. 1) 다차원 배열/구조체로 접근, 2) 함수에 call-by-reference로 넘겨 포인터 자체를 수정. 이 두 가지 경우를 아래에서 자세히 살펴보겠습니다.

1.1. 다중 포인터로 배열/구조체 접근하기

들어가기에 앞서, 이 포스트에서 배열이 사실 포인터처럼 쓰인다는 것을 살펴보시기를 추천 드립니다.

이제 배열/구조체와 다중 포인터를 살펴봅시다. 다중 포인터는 2차원 이상의 배열을 다룰 때 사용할 수 있습니다. 가령 아래와 같은 5행 3열 (3x5) 배열을 가정합시다. 이는 즉 int[3]짜리 배열을 5개 쌓는 것이겠죠?

int arr[5][3] = {
    { 1,  2,  3 },
    { 4,  5,  6 },
    { 7,  8,  9 },
    {10, 11, 12 },
    {13, 14, 15 }
};

그래서 아래와 같이 선언하면 p는 정수 3개를 담는 (= int[3]을 담는) 1개 행짜리 포인터가 됩니다.

int (*p)[3] = arr; // "3개의 int로 구성된 배열을 가리키는 포인터"를 선언, arr의 맨 앞 주소를 대입
/* 즉, 
☞ p의 타입은 포인터 (정확히는 int (*)[3])
☞ *p의 타입은 int[3]
☞ p[i]는 i번째 행(배열)
☞ p[i][j]는 그 행의 j번째 원소
*/

이는 마치 2차원 배열처럼 접근 가능합니다.

for (int i = 0; i < 5; i++)
    for (int j = 0; j < 3; j++) 
        printf("%d ", p[i][j]); // 2차원 배열처럼 접근 가능
    printf("\n");

아래는 코드에 분명 포인터가 없지만 인자가 call-by-reference로 넘어가는 예시입니다.

#include <stdio.h>

void printMatrix(int matrix[3][4]) {
    printf("Matrix:\n");
    for (int i=0; i<3; i++) {
        for (int j=0; j<4; j++)
            printf("%3d ", matrix[i][j]);
        printf("\n");
    }
}

void modifyMatrix(int matrix[3][4]) {
    for (int i=0; i<3; i++) {
        for (int j=0; j<4; j++)
            matrix[i][j] = matrix[i][j] * 10;
    }
}

int main() {
    int myArray[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    printf("수정 전:\n");
    printMatrix(myArray);

    printf("modifyMatrix로 들어갑니다...\n");
    modifyMatrix(myArray);
    printf("modifyMatrix 완료!\n");

    printf("수정 후:\n");
    printMatrix(myArray);

    return 0;
}

실행 결과는 아래와 같습니다. 분명 & 붙인 적 없고, * 쓴 적 없습니다. 그러나 함수를 한번 거치니 값이 바뀌었습니다.

아래는 하는 일은 똑같지만 배열을 포인터 변수로 받는 예시입니다.

#include <stdio.h>

void printMatrix(int (*matrix)[4], int rows, int cols) {
    printf("Matrix:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) 
            printf("%3d ", matrix[i][j]);
        printf("\n");
    }
}

void modifyMatrix(int (*matrix)[4], int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) 
            matrix[i][j] = matrix[i][j] * 10;
    }
}

int main() {
    int myArray[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    printf("수정 전:\n");
    printMatrix(myArray, 3, 4);

    printf("modifyMatrix로 들어갑니다...\n");
    modifyMatrix(myArray, 3, 4);
    printf("modifyMatrix 완료!\n");

    printf("수정 후:\n");
    printMatrix(myArray, 3, 4);

    return 0;
}

1.2. 다중 포인터로 피호출 함수에서 포인터 자체를 수정하기

int val = 42;
int *ptr1 = &val;   // 포인터 ptr1는 val의 주소를 저장
int **ptr2 = &ptr2;     // 이중 포인터 ptr2는 ptr1의 주소를 저장

위 코드는 새 포인터 변수를 선언 및 &ptr2를 대입하는데, 그 대신, callee1(&ptr2);로 다른 함수를 호출하면, 이게 바로 함수에서 포인터 자체를 수정하는 예시가 됩니다. 그렇게 callee1의 파라미터는 별이 하나 늘어납니다.

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

void callee1(int ***ptr3) {
    **ptr3 = (int *)malloc(sizeof(int));
    if (**ptr3 == NULL) 
        return;
    ***ptr3 = 321; // 321을 대입
}

int main() {
    int value = 123;
    int *ptr1 = &val; 
    int **ptr2 = &ptr1;

    printf("호출 전 value: %d\n", **ptr2); // 출력 결과 123
    callee1(&ptr2);
    printf("호출 후 value: %d\n", **ptr2); // 출력 결과 321
    free(*ptr2); 
}

이번에는 구조체를 예시로 보여드리겠습니다. 아래 코드는 간단한 이진 탐색 트리 (BST) 예제입니다.

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

typedef struct _bstnode{
    int item;
    struct _bstnode *left;
    struct _bstnode *right;
} BSTNode; 

void insertBSTNode(BSTNode **node, int value){
    if (*node == NULL){
        *node = malloc(sizeof(BSTNode));
        if (*node != NULL) {
            (*node)->item = value;
            (*node)->left = NULL;
            (*node)->right = NULL;
        }
    }else{
        if (value < (*node)->item)
            insertBSTNode(&((*node)->left), value);
        else if (value >(*node)->item)
            insertBSTNode(&((*node)->right), value);
        else
            return;
    }
}

void inOrderTraversal(BSTNode *root){
    if (root == NULL) 
        return;
    else{
        inOrderTraversal(root->left);
        printf("%d ", root->item);
        inOrderTraversal(root->right);
    }
}

int main(){
    int c, i;
    c = 1;

    BSTNode *root;
    root = NULL;

    printf("이진 탐색 트리의 루트에 넣을 값 입력: ");
    scanf("%d", &i);
    insertBSTNode(&root, i);

    printf("입력 후 BST: ");
    inOrderTraversal(root);
    printf("\n");

    return 0;
}

여기서 특히 주목해야 할 것은 바로 노드 삽입을 위한 insertBSTNode와 내용물 출력을 위한 inOrderTraversal의 파라미터 차이입니다. 아래 보시다시피 전자는 **node, 후자는 *root를 받습니다. 이유가 무엇일까요?

바로 전자는 root 노드를 수정, 후자는 읽기만 수행하기 때문입니다.

insertBSTNode는 호출된 뒤 루트 노드가 NULL이면 새로운 노드를 할당하여 root 포인터를 업데이트하는데, 만약 이걸 *로 받으면 루트 노드가 업데이트되어도 해당 함수 한정이 되며, main()으로 돌아가는 순간 해당 수정 사항은 버려집니다. 그렇기에 포인터의 포인터를 인자로 받는 것입니다.

한편 inOrderTraversal은 트리의 구조를 변경할 필요가 없습니다. 따라서 노드 포인터(*root)를 사용합니다.

그렇게 우리는 "아하! insertBSTNode(&root, i)처럼 &root를 넘기면 수정이 되고 inOrderTraversal(root)처럼 root를 넘기면 읽기만 되는구나!" 같은 단순한 생각을 하게 됩니다.

2. 별이 다섯 개!

혹시 위 내용을 보고 "함수가 하나 호출될 때마다 별이 하나씩 늘어나는 건가?"라고 생각하셨다면, 네, 정답입니다. "수정을 위해 &를 붙이는구나"라는 생각으로 짜다 보면, 아래와 같이 별이 다섯 개를 보는 기적을 경험하실 수 있습니다.

#include <stdio.h>

void callee3(char *****p4) {
    static char *new_data[] = { "별이", "다섯", "개!!!!!", NULL };
    ***p4 = new_data;
}

void callee2(char ****p3) {
    printf("현재 callee2. callee3에게 넘김.\n");
    callee3(&p3);
}

void callee1(char ***p2) {
    printf("현재 callee1. callee2에게 넘김.\n");
    callee2(&p2);
}

int main() {
    static char *original[] = { "하나", "둘", "셋", NULL };
    char **asdasd = original;

    printf("수정 전: %s, %s, %s\n", asdasd[0], asdasd[1], asdasd[2]); // 하나 둘 셋
    callee1(&asdasd);  // 별의 향연 시작!
    printf("수정 후: %s, %s, %s\n", asdasd[0], asdasd[1], asdasd[2]); // 별이 다섯 개!!!!!

    return 0;
}

코드를 저렇게 짜면 될까요? 안될까요? 물론 개발자 개개인의 특이한 취향은 저도 존중해 마지않습니다만, 협업을 위해 저희가 고를 수 있는 선택지란 그렇게 다양하지 않을 수도 있음을 항상 유념해야 할 것입니다. 아래는 동일한 기능을 수행하지만 줄곧 별 3개를 유지하는 코드입니다.

#include <stdio.h>

void callee3(char ***p2) {
    static char *new_data[] = { "별이", "늘어나지", "않음!", NULL };
    *p2 = new_data;
}

void callee2(char ***p2) {
    printf("현재 callee2. callee3에게 넘김.\n");
    callee3(p2);
}

void callee1(char ***p2) {
    printf("현재 callee1. callee2에게 넘김.\n");
    callee2(p2);
}

int main() {
    static char *original[] = { "하나", "둘", "셋", NULL };
    char **asdasd = original;

    printf("Before: %s, %s, %s\n", asdasd[0], asdasd[1], asdasd[2]); // 하나 둘 셋
    callee1(&asdasd);  // asdasd의 주소를 넘겨줌.
    printf("After: %s, %s, %s\n", asdasd[0], asdasd[1], asdasd[2]); // 별이 늘어나지 않음!

    return 0;
}

분명히 동일한 기능을 수행하는데, 왜 아래는 별이 늘어나지 않을까요?

그 원인은 인자를 값으로 넘기느냐, 주소 자체를 넘기느냐의 차이입니다. 원래 코드는 main()에서 선언한 asdasd(타입 char **, 즉 별 2개)의 주소를 넘기기에, callee1이 받은 것은 이 값의 복사본(별 2개짜리 변수)입니다. 문제는 이후에도 계속 주소를 넘긴다는 데에 있습니다. & 연산자를 적용하여, 피호출 함수들이 파라미터로 받는 것은 결국 바로 직전 호출자의 로컬 복사본의 주소값입니다 (&asdasd → &p2 → &p3 → &p4 → &p5 → &p6 → ...). 이에 대하여 아래와 같이 도식화가 가능합니다.

"별이 다섯 개"의 메모리 도식화
          ┌----------------------------┐
callee3   │ p4 -> &p3 (callee2의 로컬)  │
          └----------------------------┘
callee2   │ p3 -> &p2 (callee1의 로컬)  │
          └----------------------------┘
callee1   │ p2 -> &asdasd (main의 로컬) │ 
          └----------------------------┘
main      │ asdasd -> original[]       │  ← 바꾸고 싶은 진짜 대상
          └----------------------------┘

반면, 수정된 코드에서는 main()의 변수 asdasd에 대한 주소(타입 char ***, 즉 별 3개)를 넘겨준 뒤, 이후 피호출 함수에서는 해당 주소값을 값으로 넘깁니다. 즉 피호출 레벨이 몇이 되든 결국 파라미터로 넘어가는 것은 동일한 &asdasd입니다. 이를 통해 호출 계층 내내 동일한 포인터 레벨(별 3개)을 유지하면서 원본 변수에 직접 접근할 수 있게 됩니다. 결과적으로 모든 피호출 함수들은 같은 메모리 주소를 바라보고 있으므로, 최종적으로 포인터 레벨의 변함 없이도 callee3에서 수정한 값인 new_data가 main()의 asdasd에 반영되어 출력됩니다. 이는 아래와 같이 도식화될 수 있습니다.

"별이 늘어나지 않음"의 메모리 도식화
          ┌----------------------------┐
callee3   │ p2 -> &asdasd (main의 로컬) │
          └----------------------------┘
callee2   │ p2 -> &asdasd              │
          └----------------------------┘
callee1   │ p2 -> &asdasd              │
          └----------------------------┘
main      │ asdasd -> original[]       │  ← 바꾸고 싶은 진짜 대상
          └----------------------------┘

즉, 포인터를 여러 함수에 넘길 때 피호출 함수에게 보내는 포인터의 레벨이 달라지는 이유는, 값으로 전달된 포인터의 복사본에서 추가적인 주소 연산을 수행하면 원본과는 분리된 메모리 공간에서 작업이 이루어지기 때문입니다. 이를 피하기 위해서는 처음부터 원본 변수의 주소를 전달해 모든 함수들이 동일한 레벨의 포인터를 사용하게 해야 합니다.

이렇게 이번 포스트에서는 다중 포인터의 개념, 활용 사례, 그리고 무엇보다도 중요한 피호출 함수에서 별이 증가하는 것을 막는 방법에 대하여 알아보았습니다.