Study_IT

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

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

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

배열의 이름은 값을 바꿀 수 없는 상수 형태의 포인터 이다.

#include <stdio.h>

int main(void)
{
    int arr[] = {0,1,2};
    printf("배열의 이름 : %p\n", arr);
    printf("첫 번째 요소 : %p\n",&arr[0]);
    printf("두 번째 요소 : %p\n",&arr[1]);
    printf("세 번째 요소 : %p\n",&arr[2]);
    return 0;
}
/* output : 
배열의 이름 : 0061FF14
첫 번째 요소 : 0061FF14
두 번째 요소 : 0061FF18
세 번째 요소 : 0061FF1C
*/

int형 배열의 요소간 주소 값의 차는 4바이트 인것을 확인할 수 있다. 또한 모든 배열 요소는 메모리 공간에 나란히 할당됨을 알 수 있다. 배열의 이름은 배열의 시작 주소 값을 의미하고, 그 형태는 값의 저장이 불가한 상수이다. 

배열의 이름도 포인터이기 때문에 배열의 이름을 피연산자로 하는  * 연산이 가능하다.

#include <stdio.h>

int main(void)
{
    int arr1[] = {1,2,3};
    double arr2[] = {1.1,2.2,3.3};

    printf("%d %g\n", *arr1, *arr2);
    *arr1 += 100;
    *arr2 += 120.5;
    printf("%d %g\n", *arr1, *arr2);
    return 0;
}
/* output: 
1 1.1
101 121.6
*/

배열의 이름이 가리키는 것은 배열의 첫번째 요소이기 때문에 배열의 이름을 대상으로 *연산을 하면 배열의 첫번째 요소에 접근된다.

#include <stdio.h>

int main(void)
{
    int arr[] = {10,20,30};
    int *ptr = &arr[0];

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

위 코드와 같이 포인터를 배열의 이름처럼 사용할 수도 있다.

C에서는 다음 코드와 같이 배열에 문자열을 저장할 수 있다.

char str[14] = "Good morning!";
char str[] = "Good morning!";

"Good morning!"은 공백 포함 13자 이지만 배열을 선언할때 길이를 14로 설정해야 하고 배열의 길이를 생략해도 길이는 14로 결정된다. 문자열의 끝에는 '\0'이라는 특수문자(escape sequence)가 자동으로 삽입되기 때문이다. 따라서 char형 배열로 문자열을 선언할 경우 특수문자 '\0'이 저장될 공간까지 고려해야 한다. '\0'은 널(null)문자 라고 한다.

#include <stdio.h>

int main(void)
{
    char str[] = "Good morning!";
    printf("size of str array : %d \n", sizeof(str));
    printf("char Null print : %c\n",str[13]);
    printf("int Null print : %d\n",str[13]);
    return 0; 
}
/* output : 
size of str array : 14
char Null print : 
int Null print : 0
*/

위 코드와 같이 널문자를 문자열로 출력하면 공백이 출력되고, 정수형으로 출력하면 0이 출력된다. 널문자의 아스키 코드 값은 0임을 알 수 있다. 

int main(void)
{
    char nu = '\0';	// 널문자 저장
    char sp = ' ';	// 공백 저장
    printf("%d %d", nu, sp);	// output : 0 32
    return 0;
}

위 코드와 같이 널문자의 아스키코드 값은 0이고 공백문자의 아스키 코드값은 32이기 때문에 문자열로 출력했을때 같아 보일지라도 널문자와 공백 문자는 다른 값이다.

다음과 같이 서식문자 %s를 사용하여 scanf()함수를 이용해 문자열을 입력받을 수 있다.

#include <stdio.h>

int main(void)
{
    char str[50];
    int idx = 0;

    printf("문자열 입력 : ");
    scanf("%s", str);   // &연산자를 사용하지 않음
    printf("입력받은 문자열 : %s\n", str);

    printf("문자열 단위 출력 : ");
    while(str[idx] != '\0')
    {
        printf("%c", str[idx]);
        idx++;
    }
    printf("\n");
    return 0;
}

정수형과 같은 데이터를 저장하는 변수 앞에는 &연산자를 붙이지만, 문자열을 입력받는 배열의 이름 앞에는 &연산자를 붙이지 않는다. 

scanf()함수로 입력받은 문자열의 끝에도 널문자가 저장된다. C에서 표현하는 모든 문자열의 끝에는 널문자가 저장된다. 만약 다음 코드와 같이 널문자가 없으면 문자열이 아니다. 문자들을 저장한 배열일 뿐이다.

char arr[] = "{'h','e','l','l','o'};

문자열에서 끝에 널문자가 저장되는 것은 메모리상에서 문자열은 이진 데이터로 저장되어 있기 때문에 문자열의 시작과 끝을 구분해주기 위해서다. 0번 인덱스가 시작위치이고, 널문자가 끝나는 위치이다. 

scanf()함수에 공백을 포함한 문자열을 입력하게 되면 출력값은 공백 이전의 문자열만 출력되게 된다. scanf()함수는 공백을 기준으로 데이터를 구분짓기 때문에 "Hello World!"를 입력하면 "Hello", "World!"로 두개의 문자열이 입력된 것으로 인식한다.

#include <stdio.h>

int main(void)
{
    char str[50] = "Hello World!";
    printf("String: %s\n", str);

    str[5]='\0';
    printf("String: %s\n", str);

    str[3]='\0';
    printf("String: %s\n", str);
    return 0;
}
/* output :
String: Hello World!
String: Hello
String: Hel
*/

문자열 중간중간 널문자를 삽입되면 문자열 끝이 변경되어 변경된 끝을 기준으로 문자열이 출력된다.

배열은 일반적인 변수와 다르게 여러 개의 값을 저장할 수 있다. 여러 개의 변수가 모여서 배열을 이룬다.

배열은 다음과 같이 선언할 수 있다.

int arr[4];

위 코드에는 배열을 이루는 요소의 자료형, 배열의 이름, 배열의 길이 이다. 따라서 위 코드의 의미는 'int형 변수 4개로 이뤄진 arr이라는 이름을 갖는 배열을 선언한다.' 이다. 이 형식을 갖추어 다양한 자료형과 다양한 길이의 배열을 선언할 수 있다.

배열은 다음과 같이 배열 이름 뒤의 대괄호([]) 안의 인덱스 값으로 접근할 수 있다. 인덱스 값은 0부터 시작한다. 배열의 길이가 3일 경우 인덱스 값은 2까지 있다.

#include <stdio.h>

int main(void)
{
    int arr[3];
    int sum = 0;

    arr[0] = 10, arr[1] = 30, arr[2] = 20;

    for(int i = 0; i < 3; i++)
        sum += arr[i];
    
    printf("배열 요소에 저장된 값들의 합 : %d\n", sum);
    return 0;
}

//output : 배열 요소에 저장된 값들의 합 : 60

위 코드는 크기가 3인 배열에 값들을 저장하여 배열의 값들의 합을 구하는 코드이다. 배열의 모든 요소는 반복문을 활용하여 순차적으로 접근 가능하다는 것을 알 수 있다.

배열도 기본 자료형 변수들과 마찬가지로 선언과 동시에 초기화하는 것이 가능하다.

다음 코드와 같이 중괄호 내에 초기화 할 값들을 나열하면 해당 값들이 순서대로 저장된다.

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

위와 같이 초기화 리스트가 사용된 경우 배열의 길이정보를 생략할 수 있다. 

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

위 코드의 경우 배열의 길이정보 5가 자동으로 채워진다.

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

위 코드의 경우 배열의 길이는 5이지만 초기화할 값은 2개밖에 존재하지 않는다. 위와 같은 경우 순차적으로 값을 채우고 채울 값이 존재하지 않는 요소들은 0으로 채워진다. 위의 경우 배열의 값은 1,2,0,0,0 과 같다.

#include <stdio.h>

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

    printf("arr1의 크기 : %d\n", sizeof(arr1));
    printf("arr2의 크기 : %d\n", sizeof(arr2));
    printf("arr3의 크기 : %d\n", sizeof(arr3));

    int ar1Len = sizeof(arr1) / sizeof(int);
    int ar2Len = sizeof(arr2) / sizeof(int);
    int ar3Len = sizeof(arr3) / sizeof(int);

    for(int i = 0; i<ar1Len; i++)
        printf("%d ", arr1[i]);
    printf("\n");
    for(int i = 0; i<ar2Len; i++)
        printf("%d ", arr2[i]);
    printf("\n");
    for(int i = 0; i<ar3Len; i++)
        printf("%d ", arr3[i]);
    printf("\n");

    return 0;
}
/* output : 
arr1의 크기 : 20
arr2의 크기 : 28
arr3의 크기 : 20
1 2 3 4 5       
1 2 3 4 5 6 7   
1 2 0 0 0
*/

sizeof로 배열의 크기를 반환하면 바이트 단위로 반환된다. 따라서 배열의 길이를 계산하려면 int 바이트수만큼 나눠줘야 한다.