[Programming/C] 여러 가지 포인터의 비교

포인터의 선언과 그 포인터의 의미

단순한 포인터

선언	타입	의미
int* np;	1차원 포인터	int형의 주소를 저장
int** npp;	2차원 포인터	int형의 2차원 주소를 저장

단순한 배열

선언	타입	의미
int arr[3];	1차원 배열	int형 값들을 저장
int arr[2][3];	2차원 배열	int형 값들을 저장

배열과 포인터

선언	타입	의미
int* arr[3];	1차원 포인터 배열	int형 주소값 3개를 저장
int (*arr)[3];	2차원 배열 포인터	포인터 연산시, int형 3개를 건너뛰는 2차원 배열 포인터이며 2차원 배열의 주소를 저장
int (*arr)[2][3];	3차원 배열 포인터	포인터 연산시, int형 2x3개를 건너뛰는 3차원 배열 포인터이며 3차원 배열의 주소를 저장
int (*arr[2])[3];	2차원 배열 포인터의 배열	포인터 연산시, int형 2개를 건너뛰는 2차원 배열 포인터 3개를 가지는 포인터 배열
int* (*arr)[3];	2차원 배열 포인터	포인터 연산시, int형 포인터 3개를 건너뛰는 2차원 배열 포인터. int형 주서를 저장하는 2차원 배열의 주소를 저장

함수와 포인터

선언	타입	의미
int* func(void);	함수 원형	int형 주소를 반환하고 매개변수가 없는 함수 원형 선언
int (*func)(void);	함수 포인터	int형을 반환하고 매개변수가 없는 함수들의 주소를 저장
int (*func[2])(void);	함수 포인터 배열	int형을 반환하고 매개변수가 없는 함수들의 주소를 저장하는 포인터 배열

---

다음은 선언한 변수들의 메모리와 간단한 예제들이다.

int* np; (1차원 포인터)

#include <stdio.h>

int main(int argc, const char * argv[]) {
    int n = 10;
    int* np;
    
    np = &n;
    
    printf("%d %d\n", n, *np);

    return 0;
}

/* 결과
10 10
*/

---

int** npp; (2차원 포인터)

#include <stdio.h>

int main(int argc, const char * argv[]) {
    int n = 10;
    int* np = &n;
    int** npp;
    
    npp = &np;
    
    printf("%d %d\n", n, **npp);

    return 0;
}

/* 결과
10 10
*/

---

int arr[3]; (1차원 배열)

#include <stdio.h>

int main(int argc, const char * argv[]) {
    int arr[3] = {1, 2, 3};
    
    printf("%d %d %d\n", arr[0], arr[1], arr[2]);

    return 0;
}

/* 결과
1 2 3
*/

---

int arr[2][3]; (2차원 배열)

#include <stdio.h>

int main(int argc, const char * argv[]) {
    int arr[2][3] = {{1, 2, 3}, {100, 200, 300}};
    
    printf("%d %d %d %d %d %d\n",
           arr[0][0], arr[0][1], arr[0][2],
           arr[1][0], arr[1][1], arr[1][2]);

    return 0;
}

/* 결과
1 2 3 100 200 300
*/

---

int* arr[3]; (int형 주소를 저장하는 배열)

#include <stdio.h>

int main(int argc, const char * argv[]) {
    int n1 = 10;
    int n2 = 20;
    int n3 = 30;
    int* arr[3] = {&n1, &n2, &n3};
    
    printf("%d %d %d\n", n1, n2, n3);
    printf("%d %d %d\n", *arr[0], *arr[1], *arr[2]);

    return 0;
}

/* 결과
10 20 30
10 20 30
*/

---

int (*arr)[3]; (2차원 배열의 주소를 저장하는 포인터 변수)

#include <stdio.h>

int main(int argc, const char * argv[]) {
    int arr2[2][3] = {{10, 20, 30}, {100, 200, 300}};
    int (*arr)[3];
    
    arr = arr2;
    
    printf("%d %d %d %d %d %d\n",
           arr[0][0], arr[0][1], arr[0][2],
           arr[1][0], arr[1][1], arr[1][2]);

    return 0;
}

/* 결과
10 20 30 100 200 300
*/

---

int (*arr)[2][3]; (3차원 배열의 주소를 저장하는 포인터 변수)

#include <stdio.h>

int main(int argc, const char * argv[]) {
    int arr3[2][2][3] = {
        {
            {1, 2, 3},
            {4, 5, 6}
        },
        {
            {7, 8, 9},
            {10, 11, 12}
        }
    };
    int (*arr)[2][3];
    
    arr = arr3;
    
    printf("%d %d %d\n", arr[0][0][0], arr[0][0][1], arr[0][0][2]);
    printf("%d %d %d\n", arr[0][1][0], arr[0][1][1], arr[0][1][2]);
    printf("%d %d %d\n", arr[1][0][0], arr[1][0][1], arr[1][0][2]);
    printf("%d %d %d\n", arr[1][1][0], arr[1][1][1], arr[1][1][2]);

    return 0;
}

/* 결과
1 2 3
4 5 6
7 8 9
10 11 12
*/

arr은 3차원 배열의 주소를 저장하기 위한 포인터 변수로 행과 열의 개수가 [2][3]인 int형 3차원 배열의 시작 주소를 저장한다.

---

int (*arr[2])[3]; (2차원 배열의 주소를 저장하는 배열)

#include <stdio.h>

int main(int argc, const char * argv[]) {
    int iarr1[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int iarr2[3][3] = {{7, 8, 9}, {10, 11, 12}, {13, 14, 15}};
    int (*arr[2])[3];
    
    arr[0] = iarr1;
    arr[1] = iarr2;
    
    printf("%d %d %d\n", arr[0][0][0], arr[0][0][1], arr[0][0][2]);
    printf("%d %d %d\n", arr[0][1][0], arr[0][1][1], arr[0][1][2]);
    puts("=============================");
    printf("%d %d %d\n", arr[1][0][0], arr[1][0][1], arr[1][0][2]);
    printf("%d %d %d\n", arr[1][1][0], arr[1][1][1], arr[1][1][2]);
    printf("%d %d %d\n", arr[1][2][0], arr[1][2][1], arr[1][2][2]);

    return 0;
}

/* 결과
1 2 3
4 5 6
=============================
7 8 9
10 11 12
13 14 15
*/

int (*arr[2])[3]은 포인터 배열이다. 배열 요소 (arr[0], arr[1])는 열의 개수가 [3]인 int형 2차원 배열의 시작 주소 등을 저장한다.

---

int* (*arr)[3]; (int* 형 2차원 배열의 주소를 저장하는 포인터 변수)

#include <stdio.h>

int main(int argc, const char * argv[]) {
    int n1 = 10, n2 = 20, n3 = 30, n4 = 40, n5 = 50, n6 = 60, n7 = 70, n8 = 80, n9 = 90;
    int* iarr1[2][3] = {{&n1, &n2, &n3}, {&n4, &n5, &n6}};
    int* iarr2[3][3] = {{&n1, &n2, &n3}, {&n4, &n5, &n6}, {&n7, &n8, &n9}};
    int* (*arr)[3];
    
    arr = iarr1;
    
    for(int i=0; i<2; i++){
        for(int j=0; j<3; j++){
            printf("%d ", *arr[i][j]);
        }
        puts("");
    }
    
    puts("");
    
    arr = iarr2;
    
    for(int i=0; i<3; i++){
        for(int j=0; j<3; j++){
            printf("%d ", *arr[i][j]);
        }
        puts("");
    }

    return 0;
}

/* 결과
10 20 30 
40 50 60 

10 20 30 
40 50 60 
70 80 90 
*/

arr은 포인터 변수로, iarr1과 iarr2와 같은 주소를 저장한다.

---

int* func(void); (함수의 원형)

#include <stdio.h>

static int n = 20;

int* func();

int main(int argc, const char * argv[]) {
    int *np;
    
    np = func();
    printf("%d %d\n", n, *np);

    return 0;
}

int* func(){
    return &n;
}

/* 결과
20 20
*/

---

int (*func)(void) (함수 포인터)

#include <stdio.h>

int func1(){
    puts("func1");
    return 1;
}

int func2(){
    puts("func2");
    return 2;
}

int main(int argc, const char * argv[]) {
    int (*func)();
    
    func = func1;
    printf("%d\n", func());
    func = func2;
    printf("%d\n", func());

    return 0;
}

/* 결과
func1
1
func2
2
*/

---

int (*func[2])(void) (함수 포인터 배열)

#include <stdio.h>

int func1(){
    puts("func1");
    return 1;
}

int func2(){
    puts("func2");
    return 2;
}

int main(int argc, const char * argv[]) {
    int (*func[2])();
    
    func[0] = func1;
    printf("%d\n", func[0]());
    func[1] = func2;
    printf("%d\n", func[1]());

    return 0;
}

/* 결과
func1
1
func2
2
*/

int (*func[2])() 는 함수의 주소 2개를 저장할 수 있는 함수 포인터 배열이다. 각 배열의 요소(func[0], func[1])는 함수의 주소를 저장한다.