Study_IT

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
*/

3차원 배열은 2차원 배열에서 높이의 개념이 추가된 배열이다. 3차원 배열은 다음과 같이 높이. 세로, 가로의 길이를 순서대로 선언한다.

int arr[2][3][4];	// 높이2, 세로3, 가로4

sizeof 연산을 이용하여 3차원 배열의 크기를 확인해보면 int 자료형의 크기 x 높이 x 세로 x 가로로 직육면체 형태의 배열임을 알 수 있다.

#include <stdio.h>

int main(void)
{
    int arr[2][3][4];
    printf("3차원 배열의 크기 : %d\n", sizeof(arr));
    return 0;
}
// output : 3차원 배열의 크기 : 96

3차원 배열은 다음과 같이 선언하고 접근한다.

#include <stdio.h>

int main(void)
{
    int sum = 0;
    int arr[3][3][2] = {
        {
            {1,2},
            {3,4},
            {5,6}
        },
        {
            {7,8},
            {9,10},
            {11,12}
        },
        {
            {13,14},
            {15,16},
            {17,18}
        }
    };

    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 2; j++)
        {
            sum += arr[0][i][j];
        }
    }
    printf("첫번째 면 모든 값의 합 : %d\n",sum);
    sum = 0;

    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 2; j++)
        {
            sum += arr[2][i][j];
        }
    }
    printf("세번째 면 모든 값의 합 : %d\n",sum);

    return 0;
}
// output : 
// 첫번째 면 모든 값의 합 : 21
// 세번째 면 모든 값의 합 : 93

3차원 배열은 2차원 배열의 형태를 갖는 여러개의 면이 겹쳐져 있는 형태이다.

2차원 배열은 다음과 같이 선언한다.

int arr[3][4];	// 세로가 3, 가로가 2인 int형 2차원 배열

2차원 배열의 선언 방식은 세로와 가로의 길이를 각각 명시한다. 이 선언으로 할당되는 배열의 모습은 다음과 같다.

위 표에서 삽입된 두개의 숫자는 배열에 접근할 때 사용하게 되는 인덱스값이다. 배열의 이름이 arr이고 배열의 자료형이 TYPE라 할 때 2차원 배열의 선언 형태는 다음과 같다.

TYPE arr[세로길이][가로길이];

sizeof 연산자를 이용하여 2차원 배열의 크기를 확인해보면 다음과 같다.

#include <stdio.h>

int main(void)
{
    int arr[3][4];
    printf("2차원 배열 크기 : %d\n", sizeof(arr));
    return 0;
}
// output : 2차원 배열 크기 : 48

int 형 배열이기 때문에 한 칸에 4씩 계산하여 48이 나온다.

2차원 배열은 다음과 같이 접근하여 값을 저장할 수 있다.

arr[2][1] = 5;
arr[0][1] = 3;

2차원 배열의 메모리 주소값도 1차원 배열과 동일한 구조이다. 예를 들어 세로3, 가로2인 2차원 배열을 선언하여 메모리 주소를 확인하면 다음과 같다. 

#include <stdio.h>

int main(void)
{
    int arr[3][2];
    
    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 2; j++)
        {
            printf("%p \n", &arr[i][j]);
        }
    }

    return 0;
}
/* output :
0061FF00 
0061FF04 
0061FF08
0061FF0C
0061FF10
0061FF14
*/

int 형 2차원 배열이기 때문에 4바이트 만큼 차이가 나는 상태로 1열로 할당되어 있다.

2차원 배열도 선언과 동시에 초기화가 가능하다. 

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

위 코드처럼 행 단위로 초기화 할 값들을 별도의 중괄호로 명시해야 한다. 

다음 코드와 같이 초기화를 생략한 요소가 있다면 빈 공간은 0으로 초기화 된다.

int arr[3][3] = {
    {1},
    {4,5},
    {7,8,9}
};

다음 코드와 같이 한 줄로 초기화 하는 것도 가능하다. 

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

위 코드와 같이 부족한 부분이 있다면 마찬가지로 0으로 채워진다.

#include <stdio.h>

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

    int arr2[3][3] = {
        {1,2,3},
        {4,5},
        {7}
    };

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

    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 3; j++)
        {
            printf("%d ", arr1[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 3; j++)
        {
            printf("%d ", arr2[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 3; j++)
        {
            printf("%d ", arr3[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}
/* output : 
1 2 3 
4 5 6
7 8 9

1 2 3
4 5 0
7 0 0

1 2 3
4 5 6
0 0 0
*/

1차원 배열처럼 배열의 길이를 명시하지 않고 초기화 하는것도 가능하다. 그러나 다음과 같이 가로와 세로의 길이를 모두 명시하지 않는 것은 불가능하다.

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

배열의 요소가 8개 이므로 1x8, 2x4, 4x2, 8x1의 경우로 여러개의 경우가 있기 때문이다.  그래서 하나를 알려줘야 하는데, 다음과 같이 세로의 길이는 생략이 가능하다. 가로 길이는 생략이 불가능하다. 가로의 길이를 생략하면 위 코드와 같이 컴파일러에서 에러를 발생한다.

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

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 = #

함수를 호출할 때 단순히 값을 전달하는 형태의 함수 호출을 Call-by-value 라 하고, 메모리의 접근에 사용되는 주소값을 전달하는 형태의 함수 호출을 Call-by-reference라 한다.  배열을 함수의 인자로 전달하는 경우는 배열의 주소값을 전달받으니 Call-by-reference 이다. 

#include <stdio.h>

void Swap(int n1, int n2)
{
    int tmp = n1;
    n1 = n2;
    n2 = tmp;
    printf("n1 n2 : %d %d\n", n1, n2);
}

int main(void)
{
    int num1 = 10, num2 = 20;
    printf("num1 num2 : %d %d\n", num1, num2);

    Swap(num1, num2);
    printf("num1 num2 : %d %d\n", num1, num2);
    return 0;
}
/* output : 
num1 num2 : 10 20
n1 n2 : 20 10
num1 num2 : 10 20
*/

#include <stdio.h>

void Swap(int * ptr1, int * ptr2)
{
    int tmp = *ptr1;
    *ptr1 = *ptr2;
    *ptr2 = tmp;
}

int main(void)
{
    int num1 = 10, num2 = 20;
    printf("num1 num2 : %d %d\n", num1, num2);

    Swap(&num1, &num2);
    printf("num1 num2 : %d %d\n", num1, num2);
    return 0;
}
/* output : 
num1 num2 : 10 20
num1 num2 : 20 10
*/

위 두 코드를 보면 첫 번째 코드는 Call-by-value 방식이고, 두 번째 코드는 Call-by-reference 방식이다. 첫 번째 코드는 값의 변경이 매개변수 n1과 n2에서만 일어나 num1과 num2의 값에는 영향을 미치지 않는다. 매개변수 사이에서만 값의 변환이 일어났다. 두 번째 코드는 주소값을 인자로 받아 주소값에 직접 접근하여 main함수의 num1과 num2의 값도 변경되었다.

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

#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;
}

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