Study_IT

프로그램 내에 정의된 다양한 함수들도 바이너리 형태로 메모리에 저장되어 호출시 실행된다. 이런 함수들의 주소도 포인터 변수에 저장할 수 있다. 배열의 이름이 배열의 시작 주소를 가리키듯, 함수의 이름도 함수가 저장된 메모리 주솟값을 나타낸다.

int SimpleFunc(int num) { ... }

위 함수의 반환형은 int 이고, 매개변수는 int num 이다. 함수의 이름 SimpleFunc는 함수의 주솟값을 의미하는 상수형태의 함수 포인터 이다. 이 함수의 포인터 형은 반환형이 int이고, 매개변수로 int형 변수가 하나 선언된 포인터형 이다.

포인터 변수의 선언은 다음과 같다.

int (*fptr) (int)

반환형이 int이며, 매개변수 선언이 int 하나인 함수 포인터 변수이다. 

다음과 같은 함수의 경우 아래와 같이 함수 포인터 변수를 선언한다.

int Func(int num1, int num2) { ... }
int (*fptr) (int, int);

그리고 다음과 같은 방식으로 Func 함수를 호출할 수 있다.

fptr(2,5);

다음 코드는 함수 포인터 변수를 활용한 예시이다.

#include <stdio.h>

void SimpleAdder(int n1, int n2)
{
    printf("%d + %d = %d\n", n1, n2, n1+n2);
}

void ShowString(char * str)
{
    printf("%s\n", str);
}

int main(void)
{
    char *str = "Function Pointer";
    int num1 = 10, num2 = 20;

    void(*fptr1)(int, int) = SimpleAdder;
    void(*fptr2)(char *) = ShowString;
    fptr1(num1, num2);
    fptr2(str);
    return 0;
}
/* output : 
10 + 20 = 30
Function Pointer
*/

#include <stdio.h>

int WhoIsFirst(int age1, int age2, int (*cmp)(int n1, int n2))
{
    return cmp(age1, age2);
}

int OlderFirst(int age1, int age2)
{
    if(age1 > age2)
        return age1;
    else if(age2 > age1)
        return age2;
    else
        return 0;
}

int YoungerFirst(int age1, int age2)
{
    if(age1<age2)
        return age1;
    else if(age2<age1)
        return age2;
    else
        return 0;
}

int main(void)
{
    int age1 = 20, age2 = 30;
    int first;

    printf("입장순서 1 \n");
    first = WhoIsFirst(age1, age2, OlderFirst);
    printf("%d세와 %d세중 %d세가 먼저 입장\n", age1, age2, first);

    printf("입장순서 2 \n");
    first = WhoIsFirst(age1, age2, YoungerFirst);
    printf("%d세와 %d세중 %d세가 먼저 입장\n", age1, age2, first);
    return 0;
}
/* output : 
입장순서 1 
20세와 30세중 30세가 먼저 입장
입장순서 2 
20세와 30세중 20세가 먼저 입장
*/

위 코드와 같이 함수의  매개변수로 함수 포인터 변수를 넣을 수 도 있다.

int arr2d[3][3];

위의 2차원 배열은 다음과 같은 모양을 갖는다.

2차원 배열의 경우 arr2d[0], arr2d[1], arr2d[2]도 각각 1행, 2행, 3행의 첫 번째 요소를 가리킨다.

또한 2차원 배열의 첫 번째 요소의 주소 값을 출력할 때는 다음 두 가지 형태로 동일하게 출력이 가능하다.

printf("%p\n", arr2d);
printf("%p\n", arr2d[0]);

#include <stdio.h>

int main(void)
{
    int arr2d[3][3];
     printf("%d\n", arr2d);
     printf("%d\n", arr2d[0]);
     printf("%d\n\n", &arr2d[0][0]);

    printf("%d\n", arr2d[1]);
    printf("%d\n\n",&arr2d[1][0]);

     printf("%d\n", arr2d[2]);
     printf("%d\n\n", &arr2d[2][0]);

     printf("sizeof(arr2d) : %d\n", sizeof(arr2d));
     printf("sizeof(arr2d[0]) : %d\n", sizeof(arr2d[0]));
     printf("sizeof(arr2d[1]) : %d\n", sizeof(arr2d[1]));
     printf("sizeof(arr2d[2]) : %d\n", sizeof(arr2d[2]));
    return 0;
}
/* output
 -272632624
 -272632624
 -272632624

 -272632612
 -272632612

 -272632600
 -272632600

 sizeof(arr2d) : 36
 sizeof(arr2d[0]) : 12
 sizeof(arr2d[1]) : 12
 sizeof(arr2d[2]) : 12
 */

 위 코드와 같이 arr2d는 첫 번째 요소를 가리키며, 배열 전체를 의미한다.  arr2d[0]은 첫 번째 요소를 가리키며 1행만을 의미한다. 그래서 sizeof 연산 결과 arr2d는 배열 전체의 크기인 36이 출력되었고, arr2d[0]은 첫 번째 행의 크기인 12가 출력되었다.

1차원 배열의 경우 다음 코드에서 iarr은 int형 포인터 이기 때문에 iarr+sizeof(int)의 계산 결과가 출력되고,  darr은 double형 포인터 이므로 darr+sizeof(double)이 출력된다.

int iarr[3];
double darr[7];

printf("%p\n", iarr+1);
printf("%p\n", darr+1);

또한 2차원 배열을 대상으로 증가 연산을 진행해보면 다음과 같다.

#include <stdio.h>

int main(void)
{
    int arr1[3][2];
    int arr2[2][3];

    printf("arr1 : %p\n", arr1);
    printf("arr1+1 : %p\n", arr1+1);
    printf("arr1+2 : %p\n\n", arr1+2);

    printf("arr2 : %p\n", arr2);
    printf("arr2+1 : %p\n", arr2+1);
    return 0;
}
/* output : 
@"arr1 : 0x7ffeefbff7c0\r\n"
@"arr1+1 : 0x7ffeefbff7c8\r\n"
@"arr1+2 : 0x7ffeefbff7d0\r\n"
@"\r\n"
@"arr2 : 0x7ffeefbff7a0\r\n"
@"arr2+1 : 0x7ffeefbff7ac\r\n"
*/

첫 번째 배열의 경우 1씩 증가시켰을 때 8이 증가하였고, 두 번째 배열의 경우 1을 증가시키면 12가 증가하였다. 2차원 배열 이름을 대상으로 증가 및 감소 연산을 할 경우 각 행의 첫번째 요소를 가리킨다. arr1은 1행의 첫번째 요소를 가리키며, arr1+1은 두번째 행의 첫번째 요소를 가리킨다. arr1은 가로가 한 행에 두 칸이기 때문에 8이 증가한 것이다. 2차원 배열의 포인터형은 가로의 길이에 따라서 달라진다.

2차원 배열은 포인트 연산시 sizeof(type) x 가로길이 만큼 값이 증가한다.

위와 같은 유형의 포인트 변수 선언은 int형이며, sizeof(int)x4의 크기 단위로 증가 및 감소하는 포인터 변수 선언은 다음과 같다.

int (*ptr)[4];

#include <stdio.h>

int main(void)
{
    int arr1[2][2] = {
        {1,2}, {3,4}
    };
    int arr2[3][2] = {
        {1,2}, {3,4}, {5,6}
    };
    int arr3[4][2] = {
        {1,2}, {3,4}, {5,6}, {7,8}
    };

    int (*ptr)[2];
    int i;

    ptr = arr1;
    printf("** Show 2,2 arr1 **\n");
    for(i = 0; i < 2; i++)
        printf("%d %d\n", ptr[i][0], ptr[i][1]);

    ptr = arr2;
    printf("** Show 3,2 arr2 **\n");
    for(i = 0; i < 3; i++)
        printf("%d %d\n", ptr[i][0], ptr[i][1]);
    
    ptr = arr3;
    printf("** Show 4,2 arr3 **\n");
    for(i = 0; i < 4; i++)
        printf("%d %d\n", ptr[i][0], ptr[i][1]);
      
}
/* output : 
@"1 2\r\n"
@"3 4\r\n"
@"** Show 3,2 arr2 **\r\n"
@"1 2\r\n"
@"3 4\r\n"
@"5 6\r\n"
@"** Show 4,2 arr3 **\r\n"
@"1 2\r\n"
@"3 4\r\n"
@"5 6\r\n"
@"7 8\r\n"
*/

위 코드와 같이 포인터 변수를 선언하여 2차원 배열에 접근할 수 있다.

2차원 배열의 주소 값을 인자로 전달 받는 함수를 정의할 때 매개 변수는 다음과 같이 선언할 수 있다.

void Function(int (*parr1)[7], double (*parr2)[5]) {...}
void Function(int parr[][7], double parr[][5]) {...}

위 두 방식의 매개변수 선언은 동일한 방식이다.

#include <stdio.h>

void ShowArr2DStyle(int (*arr)[4], int column)
{
    int i,j;
    for(i=0; i<column; i++){
        for(j=0; j<4; j++)
            printf("%d ", arr[i][j]);
        printf("\n");
    }
    printf("\n");
}

int Sum2DArr(int arr[][4], int column)
{
    int i, j, sum=0;
    for(i=0; i<column; i++)
        for(j=0; j<4; j++)
            sum+=arr[i][j];
    return sum;
}

int main(void)
{
    int arr1[2][4] = {1,2,3,4,5,6,7,8};
    int arr2[3][4] = {1,1,1,1,3,3,3,3,5,5,5,5};

    ShowArr2DStyle(arr1, sizeof(arr1)/sizeof(arr1[0]));
    ShowArr2DStyle(arr2, sizeof(arr2)/sizeof(arr2[0]));
    printf("arr1의 합 : %d\n", Sum2DArr(arr1, sizeof(arr1)/sizeof(arr1[0])));
    printf("arr2의 합 : %d\n", Sum2DArr(arr2, sizeof(arr2)/sizeof(arr2[0])));
    return 0;
}
/* output : 
1 2 3 4 
5 6 7 8 

1 1 1 1 
3 3 3 3 
5 5 5 5 

arr1의 합 : 36
arr2의 합 : 36
*/

위 코드의 다음과 같은 연산은 배열의 세로길이를 계산하는 것이다.

sizeof(arr1) / sizeof(arr1[0])
sizeof(arr2) / sizeof(arr2[0])

sizeof(arr1)은 배열의 전체 크기를 나타내고, sizeof(arr1[0])은 배열의 가로의 크기를 나타내기 때문에 위 코드는 배열의 세로 길이를 의미한다.

int arr[3][2] = { {1,2}, {3,4}, {5,6} };

2차원 배열이 위와 같이 선언되어 있을 때, 인덱스 [2][1]의 위치의 값을 4로 변경하려면 다음의 코드들을 이용할 수 있다.

arr[2][1] = 4;
(*(arr+2))[1] = 4;
*(arr[2]+1) = 4;
*(*(arr+2)+1) = 4;

포인터를 선언할 때 * 연산자가 둘 이상 사용되면 다중 포인터라 한다. *연산자는 얼마든지 사용될 수 있다.

다음과 같이 *연산자가 3개이상 삽입된 포인터 변수를 삼중 포인터 변수라고 한다. 

int ***tptr;

삼중 포인터 변수는 이중(더블) 포인터 변수를 가리키는(주소값을 저장하는) 용도로 사용된다.  

#include <stdio.h>

int main(void)
{
    int num = 100;
    int *ptr = &num;
    int **dptr = &ptr;
    int ***tptr = &dptr;

    printf("%d %d\n", **dptr, ***tptr);
    return 0;
}
// output : 100 100

위 코드는 삼중포인터의 선언과 접근에 대한 예시이다.