Study_IT

다음과 같이 선언되는 포인터를 void형 포인터라 한다.

void * ptr;

void형 포인터 변수는 함수의 주소를 포함한 어떠한 변수의 주소값이든 담을 수 있다.

#include <stdio.h>

void SimpleFunc(void)
{
    printf("Simple function\n");
}

int main(void)
{
    int num = 20;
    void *ptr;
    
    ptr = &num;
    printf("%p\n", ptr);

    ptr = SimpleFunc;
    printf("%p\n", ptr);
    return 0;
}
/* output : 
0x7ffee8607858
0x1075fbf00
*/

위 코드처럼 어떤 형태의 변수의 주소값이든 저장할 수 있다. 그러나 void형 포인터 변수는 형(type)에 대한 정보가 없기 때문에 포인터 연산, 값의 변경, 참조가 불가능하다.

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

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

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

포인터 변수를 가리키는 또 다른 포인터 변수를 더블 포인터 또는 이중 포인터 라고 한다. 선언은 다음과 같이 * 연산자를 두 개 이어서 선언 한다.

int **dptr;

int main(void)
{
    double num = 3.14;
    double *ptr = #
    double **dptr = &ptr;
}

위와 같이 코드를 작성하게 되면 num 변수에는 3.14가 저장되어 있고, ptr변수는 num 변수의 주소를 가리키고 있고, dptr 변수는 ptr변수의 주소를 가리키고 있다. 또한 dptr 변수를 사용하여 다음과 같이 ptr변수와 num 변수에 접근할 수 있다. 

*dptr = ....;		// ptr 변수에 접근
*(*dptr) = ....;	// num 변수에 접근

*(*dptr)의 경우 괄호의 생략이 가능하여 **dptr로 접근할 수도 있다.

#include <stdio.h>

int main(void)
{
    double num = 3.14;
    double *ptr = &num;
    double **dptr = &ptr;
    double *ptr2;

    printf("%9p %9p\n", ptr, *dptr);
    printf("%9g %9g\n", num, **dptr);
    ptr2 = *dptr;   // ptr2 = ptr과 같음
    *ptr2 = 10.22;
    printf("%9g %9g\n", num, **dptr);
    return 0;
}
/* output : 
 0061FF10  0061FF10
     3.14      3.14
    10.22     10.22
*/

위와 같이 코드를 작성했을때 num 변수는 ptr변수와 ptr2변수가 가리키고 있고, ptr변수는 dptr변수가 가리키고 있다.

위와 같은 경우 변수 num에 접근하는 방법은 다음과 같다.

**dptr = 10.5;
*ptr = 10.5;
*ptr2 = 10.5;
num = 10.5;

위 4개의 경우 모두 num 변수에 10.5가 저장된다.

배열은 시작점의 주소를 가리키는 하나의 포인터이다. 포인터를 요소로 갖는 배열은 더블 포인터가 된다. 따라서 다음과 같이 포인터를 요소로 갖는 배열은 더블 포인터를 이용하려 접근할 수 있다.

#include <stdio.h>

int main(void)
{
    int num1 = 10, num2 = 20, num3 = 30;
    int *ptr1 = &num1;
    int *ptr2 = &num2;
    int *ptr3 = &num3;

    int *ptrArr[] = {ptr1, ptr2, ptr3};
    int **dptr = ptrArr;

    printf("%d %d %d\n", *(ptrArr[0]), *(ptrArr[1]), *(ptrArr[2]));
    printf("%d %d %d\n", *(dptr[0]), *(dptr[1]), *(dptr[2]));
    return 0;
}
/* output : 
10 20 30
10 20 30
*/

const는 변수를 상수화 하기 위한 선언이다. 포인터 변수에도 const 선언이 가능하다.

#include <stdio.h>

int main(void)
{
    int num = 20;
    const int * ptr = &num;
    // *ptr = 30;   // 컴파일 에러
    num = 30;

    printf("test\n");
    return 0;
}

위 코드와 같이 const 선언한 포인터 변수가 가리키는 변수에 저장된 값을 변경하는 것은 허용되지 않는다. 그러나 num변수로 직접 값을 변경하는 것은 가능하다. 

다음 코드와 같이 const 선언은 포인터 변수의 이름 앞에 올 수 도 있다.

int * const ptr = #

위와 같이 변수 이름 앞에 const 선언을 했을 경우에는 주소 값의 변경이 불가능하다. 한 번 가리키기 시작한 변수를 끝까지 가리켜야 한다는 것이다. 가리키는 다음과 같이 가리키는 대상에 대한 저장된 값의 변경은 가능하다.

*ptr = 30;

다음과 같이 const선언을 하게 되면 주소값의 변경과, 가리키는 대상이 저장된 값 모두 변경이 불가능하다.

const int * const ptr = #

배열을 통째로 함수의 인자로 전달하는 것은 불가능하다. 그러나 배열을 함수의 인자로 전달하면 배열 시작점의 주소값이 전달 되기 때문에 함수의 매개변수를 포인터 변수로 선언하면 포인터 변수를 이용하여 배열에 접근할 수 있다.

#include <stdio.h>

void ShowArrayElem(int * param, int len)
{
    for(int i = 0; i<len; i++){
        printf("%d ", param[i]);
    }
    printf("\n");
}

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

/* output : 
1 2 3 
4 5 6 7 8
*/

#include <stdio.h>

void ShowArrayElem(int * param, int len)
{
    for(int i = 0; i<len; i++){
        printf("%d ", param[i]);
    }
    printf("\n");
}

void AddArrayElem(int * param, int len, int add)
{
    for(int i = 0; i < len; i++)
    {
        param[i] += add;
    }
}

int main(void)
{
    int arr[3] = {1,2,3};
    AddArrayElem(arr, sizeof(arr)/4, 1);
    ShowArrayElem(arr, sizeof(arr)/4);

    AddArrayElem(arr, sizeof(arr)/4, 2);
    ShowArrayElem(arr, sizeof(arr)/4);
    return 0;
}
/* output : 
2 3 4 
4 5 6
*/

위 코드와 같이 주소 값만 알면 배열에 저장된 값의 변경도 가능하다.

배열을 함수의 인자로 전달받을 때는 다음과 같은 선언도 가능하다. int * param과 동일한 의미이다.

void ShowArrayElem(int param[], int len)

포인터 변수로 이루어져서 주소 값의 저장이 가능한 배열을 포인터 배열이라고 한다. 포인터 배열은 다음과 같이 선언한다. 

int *arr1[20];	// 길이가 20인 int형 포인터 배열
double *arr2[30];	// 길이가 30인 double형 포인터 배열

포인터 배열의 선언은 기본 자료형 배열의 선언과 비슷하다.

#include <stdio.h>

int main(void)
{
    int num1=10, num2=20, num3=30;
    int *arr[3] = {&num1,&num2,&num3};

    printf("%d\n", *arr[0]);
    printf("%d\n", *arr[1]);
    printf("%d\n", *arr[2]);
    return 0;
}
/* output : 
10
20
30
*/

위 코드와 같이 배열과 비슷하게 선언하지만 포인터 배열은 주소값을 저장할 수 있고 주소값으로 접근할 수 있다.

다음과 같이 문자열도 포인터 배열로 저장할 수 있다.

#include <stdio.h>

int main(void)
{
    char *strArr[3] = {"simple", "string", "array"};
    printf("%s\n", strArr[0]);
    printf("%s\n", strArr[1]);
    printf("%s\n", strArr[2]);
    return 0;
}
/* output :
simple
string
array
*/

다음과 같이 포인터를 기반으로 문자열을 선언하는 것이 가능하다.

char *str = "My String";

이렇게 선언을 하면 메모리 공간에 "My String"이 저장되고, 문자열의 첫 번째 문자 M의 주소 값이 반환되어 포인터 변수 str에 저장된다. 배열로 선언한 문자열의 경우 계속해서 그 문자열을 가리키지만, 포인터로 선언한 문자열은 다음과 같이 다른 위치를 가리키도록 할 수 있다.

int main(void)
{
    char *str = "My String";
    str = "Your String";	// str이 가리키는 대상을 변경
}

배열로 선언된 문자열은 값의 변경이 가능하기 때문에 변수 형태의 문자열 이라 하고,  포인터로 선언된 문자열은 값이 변경이 불가능하여 상수 형태의 문자열 이라 한다.

#include <stdio.h>

int main(void)
{
    char str1[] = "My String";
    char *str2 = "Your String";
    printf("%s %s\n", str1, str2);

    str2 = "Our String";    // 가리키는 대상 변경
    printf("%s %s\n", str1, str2);

    str1[0] = 'X';      // 정상적으로 변경됨
    //str2[0] = 'X';    // 컴파일에서 에러 발생
    printf("%s %s\n", str1, str2);
    return 0;
}

위 코드와 같이 포인터로 선언한 문자열의 값을 변경하려 할때 컴파일이 정상적으로 안되는것을 확인할 수 있다.

포인터 변수를 대상으로도 증가 및 감소 연산이 가능하다.

#include <stdio.h>

int main(void)
{
    int * ptr1 = 0x0010;
    double * ptr2 = 0x0010;

    printf("%p %p\n", ptr1+1, ptr1+2);  // 4증가, 8증가
    printf("%p %p\n", ptr2+1, ptr2+2);  // 8증가, 16증가

    printf("%p %p\n", ptr1, ptr2);
    ptr1++;
    ptr2++;
    printf("%p %p\n", ptr1, ptr2);
    return 0;
}
/* output: 
00000014 00000018
00000018 00000020
00000010 00000010
00000014 00000018
*/

위 코드의 결과값을 보면 int형 포인터를 대상으로 1증가 시키면 4가 증가하고, double형 포인터를 대상으로 1증가시키면 8 이 증가한다. 포인터의 증감연산은 n 크기 만큼 증가 및 감소시 n x (자료형의 크기)만큼 주소값이 증가 및 감소함을 알 수 있다. 

포인터 연산을 활용하여 다음과 같이 배열의 요소에 접근할 수 있다.

int main(void)
{
    int arr[] = {1,2,3};
    int *ptr = arr;
    
    printf("%d\n", *(ptr+1));	// 2
    return 0;
}