C Basics 5/ (열혈 프로그래밍)

😙 점점 C언어 기초가 끝나간다. 다차원 배열부터 포인터의 포인터, void 포인터까지 16장부터 20장까지의 내용을 다룬다.

---

16. 다차원 배열

① 2차원 배열 / 선언 / 접근 / sizeof

ex) 세로가 3, 가로가 4인 int형 2차원 배열 선언은 int arr1[3][4]; (세로가 3, 가로가 4인 2차원 배열)

ex) 여러 배열의 형태

→ sizeof 연산자를 사용하면 2차원 배열의 크기를 계산할 수 있다. 세로 길이 x 가로 길이 x 자료형 크기로 배열의 크기가 나온다.

#include <stdio.h>

int main(void) {
  int arr1[3][4];
  int arr2[7][9];
  printf("arr1 size: %d\n",sizeof(arr1)); //arr1 size: 48
  printf("arr2 size: %d\n",sizeof(arr2)); //arr2 size: 252
  return 0;
}

 

→ 2차원 배열요소의 접근은 arr[x][y]로 직접 = 대입연산자를 사용해 기존 배열 원소의 값을 바꿀 수 있다.

 

ex) 빌라의 각 거주인원 입력받고 층별 인원수 합 출력하기

#include <stdio.h>

int main(void) {
  int villa [4][2];
  int popu, i, j;

  for(i=0;i<4;i++){
    for(j=0;j<2;j++){
      printf("floor %d ho %d population: ",i+1,j+1);
      scanf("%d",&villa[i][j]);
    }
  }

  for(int i = 0; i < 4; i++){
    popu = 0;
    popu += villa[i][0];
    popu += villa[i][1];
    printf("%d floor total population: %d\n",i+1,popu);
  }
  return 0;
}
/*
floor 1 ho 1 population: 2
floor 1 ho 2 population: 4
floor 2 ho 1 population: 3
floor 2 ho 2 population: 5
floor 3 ho 1 population: 2
floor 3 ho 2 population: 6
floor 4 ho 1 population: 4
floor 4 ho 2 population: 3
1 floor total population: 6
2 floor total population: 8
3 floor total population: 8
4 floor total population: 7
*/

 

② 2차원 배열의 메모리 할당

→ 우리가 사용하는 메모리의 주소 값은 1차원적 구조. 따라서 2차원 배열도 메모리 상에는 1차원의 형태로 존재한다.
→ Application - 운영체제(OS) - 물리적 메모리 이렇게 3단 구조로 되어 있는데, 운영체제 OS가 물리적인 메모리를 활용하는 데 역할 있음

 

ex) int arr[2][3]의 메모리상 구조

 

: 실제 위 그림의 형태로 배열이 할당되는 지 확인하기 위해 2차원 배열요소의 주소 값 출력

#include <stdio.h>

int main(void) {
  int arr[2][3];
  int i, j;
  for(i=0;i<2;i++)
    for(j=0;j<3;j++)
      printf("%p\n",&arr[i][j]);
  return 0;
}
/*
0x7ffedddb8b10
0x7ffedddb8b14
0x7ffedddb8b18
0x7ffedddb8b1c
0x7ffedddb8b20
0x7ffedddb8b24
*/

 

③ 2차원 배열 초기화

(1) 선언과 동시에 초기화

→ 1차원 배열과 마찬가지로 2차원 배열도 선언과 동시에 초기화가 가능하다. 일부 요소에 대해서는 초기화 생략 가능. 비게 되는 공간은 1차원 배열의 경우와 마찬가지로 0으로 초기화된다.

ex) 하단 초기화하는 방법 3가지

#include <stdio.h>

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

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

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

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

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

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

/*
1 2 3 
4 5 6 
7 8 9 

1 0 0 
4 5 0 
7 8 9 

1 2 3 
4 5 6 
7 0 0 
*/

 

(2) 배열의 크기를 알려주지 않고 초기화

→ 배열의 세로길이만 생략이 가능하다 ex) int arr1[][4] = {1, 2, 3, 4, 5, 6, 7, 8};
→ 배열의 가로길이는 생략이 불가능. 배열 내의 원소 가로길이가 확정된 상태에서 1행에서부터 시작해 원소가 나열되기에 가로길이는 필수로 알아야 한다.

ex1) 가로 길이가 9, 세로 길이가 3인 int형 2차원 배열을 선언하여 구구단 중 2단, 3단, 4단을 저장하자. 그리고 2차원 배열 출력

#include <stdio.h>

int main(void) {
  int gugu[3][9];

  for(int i = 0; i < 3; i++){
    printf("%d dan\n",i+2);
    for(int j = 0; j < 9; j++){
      printf("result of %d x %d? ",i+2,j+1);
      scanf("%d",&gugu[i][j]);
    }
  }

  for(int i = 0; i < 3; i++){
    for(int j = 0; j < 9; j++){
      printf("%d ",gugu[i][j]);
    }
    printf("\n");
  }
  
  return 0;
}
/*
2 dan
result of 2 x 1? 2
result of 2 x 2? 4
result of 2 x 3? 6
result of 2 x 4? 8
result of 2 x 5? 10
result of 2 x 6? 12
result of 2 x 7? 14
result of 2 x 8? 16
result of 2 x 9? 18
3 dan
result of 3 x 1? 3
result of 3 x 2? 6
result of 3 x 3? 9
result of 3 x 4? 12
result of 3 x 5? 15
result of 3 x 6? 18
result of 3 x 7? 21
result of 3 x 8? 24
result of 3 x 9? 27
4 dan
result of 4 x 1? 4
result of 4 x 2? 8
result of 4 x 3? 12
result of 4 x 4? 16
result of 4 x 5? 20
result of 4 x 6? 24
result of 4 x 7? 28
result of 4 x 8? 32
result of 4 x 9? 36
2 4 6 8 10 12 14 16 18 
3 6 9 12 15 18 21 24 27 
4 8 12 16 20 24 28 32 36 
*/

 

ex2) 배열 A = {1, 2, 3, 4, 5, 6, 7, 8}과 배열 B = {1, 5, 2, 6, 3, 7, 4, 8} 각각 [2][4] 형태, [4][2] 형태의 배열에서 배열 A는 선언과 동시에 초기화 진행. 그리고 배열 B역시 초기화를 진행하지만, 반드시 배열 A에 저장된 값을 이용해서 초기화 진행하자

 

→ [a][b] index가 배열 B로 넘어가면서 [b][a] index로 바뀐다.

#include <stdio.h>

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

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

 

ex3) 성적관리 프로그램. 국어 / 영어 / 수학 / 국사 이렇게 네 과목이고 학생은 네 사람이다. 프로그램 사용자로부터 네 사람의 네 과목 점수를 입력받는다. 미리 선언해 놓은 배열에 총점까지 총 5 x 5 2차원 배열로 저장. 마지막에 배열 출력

#include <stdio.h>

int main(void) {
  int arr[5][5] ={0};
  int sum_of_student = 0;
  int sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0;
  for(int i = 0; i < 4; i++){
    sum_of_student = 0;
    printf("student %d grade\n",i+1);
    for(int j = 0; j < 4; j++){
      printf("grades: ");
      scanf("%d",&arr[i][j]);
      sum_of_student += arr[i][j];
    }
    arr[4][0] += arr[i][0];
    arr[4][1] += arr[i][1];
    arr[4][2] += arr[i][2];
    arr[4][3] += arr[i][3];
    arr[i][4] = sum_of_student;
    arr[4][4] += sum_of_student;
  }
  
  //print array
  for(int i = 0; i < 5; i++){
    for(int j = 0; j < 5; j++){
      printf("%-3d", arr[i][j]);
    }
    printf("\n");
  }
  
  return 0;
}
/*
student 1 grade
grades: 5
grades: 4
grades: 6
grades: 5
student 2 grade
grades: 3
grades: 6
grades: 9
grades: 3
student 3 grade
grades: 4
grades: 8
grades: 2
grades: 7
student 4 grade
grades: 3
grades: 8
grades: 9
grades: 7
5  4  6  5  20 
3  6  9  3  21 
4  8  2  7  21 
3  8  9  7  27 
15 26 26 22 89
*/

 

④ 3차원 배열 : 가로와 세로 2차원 배열에 높이의 개념이 추가되어 3차원 배열 형성

ex1) int arr1[2][3][4]; (높이가 2, 세로가 3, 가로가 4인 int형 3차원 배열)
ex2) double arr2[5][5][5]; (높이, 세로, 가로 모두 5인 double형 3차원 배열)

→ 3차원 배열의 sizeof() 연산 결과 높이 x 가로길이 x 세로길이 x sizeof(데이터 타입)이 나온다.

 

ex) 각 class별 학생별 성적 (한 class의 학생별 성적이 있는 2차원 배열이 여러 개의 class로 모인 3차원 배열)

#include <stdio.h>

int main(void) {
  int mean = 0, i, j;
  int record[3][3][2] = {
  {
    {70,80}, //A class student 1 grades
    {94,90}, //A class student 2 grades
    {70,85} //A class student 3 grades
  },
  {
    {83,90}, //B class student 1 grades
    {95,60}, //B class student 2 grades
    {90,82} //B class student 3 grades
  },
  {
    {98,89}, //C class student 1 grades
    {99,94}, //C class student 2 grades
    {91,87} //C class student 3 grades
  }
};

  for(i=0;i<3;i++)
    for(j=0;j<2;j++)
      mean += record[0][i][j];
  printf("mean of A class grades: %g\n",(double)mean/6);

  mean = 0;
  for(i=0;i<3;i++)
    for(j=0;j<2;j++)
      mean += record[1][i][j];
  printf("mean of B class grades: %g\n",(double)mean/6);

  mean=0;
  for(i=0;i<3;i++)
    for(j=0;j<2;j++)
      mean += record[2][i][j];
  printf("mean of C class grades: %g\n",(double)mean/6);
  
  return 0;
}
/*
mean of A class grades: 81.5
mean of B class grades: 83.3333
mean of C class grades: 93
*/

 

→ 즉 3차원 배열은 여러 개의 2차원 배열이 모여 있는 형태로 이해하는 것이 더 합리적이다. 마찬가지로 2차원 배열은 1차원 배열이 여럿 모여 있는 형태로 쉽게 이해할 수 있다.

→ 위 예시의 경우, 가장 앞부분에 위치한 2차원 배열이 첫번째 학급이 되고, 그 다음의 2차원 배열이 두번째 학급 순으로 되는 것이다.

17. 포인터의 포인터

⑤ '이중 포인터(더블 포인터)': 포인터의 포인터로, 포인터 변수를 가리키는 또 다른 포인터 변수를 뜻한다. 포인터 변수의 선언에 사용되는 * 연산자를 두 개 이어서 선언한다. 예를 들어 int형 이중 포인터는 int ** dptr로 표현 가능하다.

ex) double *ptr = # double **dptr = &ptr;

→ 위 코드에서 double형 이중포인터 dptr은 포인터 변수 ptr을 가리키고, 포인터 변수 ptr은 변수 num을 가리킨다. 따라서 *dptr은 포인터 변수 ptr을 의미하고, *(*dptr)은(**dptr로도 표현 가능) 변수 num을 뜻한다.

ex) 예제: 변수 num의 주소가 저장된 ptr, ptr의 주소가 저장된 dptr / 그리고 ptr2 포인터 변수를 선언하고 dptr을 사용해 ptr2에 ptr의 주소를 저장, ptr2도 num을 가리키게끔 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 = 10.99;
  printf("%9g %9g\n", num, **dptr);

  return 0;
}
/*
0x7ffeb371de80 0x7ffeb371de80
     3.14      3.14
    10.99     10.99
*/

 

→ 아래 그림을 참고하면

: dptr이라는 더블 포인터를 활용해서 ptr2 포인터 변수가 num을 가리키게끔 했다. 즉, ptr2 변수에 dptr이 가리키는, 즉 num의 변수를 저장해줌으로써 자연스럽게 ptr2라는 새 포인터 변수가 num을 가리키게 했다.

 

⑥ 포인터 변수 대상의 call-by-reference

 

★ 잘못된 예시 - num1과 num2의 값이 서로 안바뀐다. ★

#include <stdio.h>

void SwapIntPtr(int *p1, int *p2){
  int * temp = p1;
  p1 = p2;
  p2 = temp;
}

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

  SwapIntPtr(ptr1, ptr2);
  printf("*ptr1, *ptr2: %d %d\n", *ptr1, *ptr2);

  return 0;
}
/*
*ptr1, *ptr2: 10 20
*ptr1, *ptr2: 10 20
*/

 

: int *p1 = ptr1이므로 ptr1은 num1의 주소이므로, int *p1 = &num1, int *p2 = &num2로 p1과 p2는 포인터 변수이며 각각 num1과 num2를 가리키고 있다.(즉 각각 num1과 num2의 주소값을 갖게 된다). 이 때, p1과 p2의 값을 swap했으므로 p1에는 num2의 주소, p2에는 num1의 주소가 들어가, 결국은 p1은 num2를 가리키게 되고, p2는 num1을 가리키게 된다. 따라서 ptr1과 ptr2는 여전히 각각 num1과 num2를 가리키게 된다. ptr1에 저장된 주소인 num1의 주소를 p1 변수에 대입, ptr2도 마찬가지이다(함수를 호출할 때) <아래 그림 참조>

→ 첫번째 과정에서 함수 매개변수가 만들어질 때 p1과 p2에 각각 ptr1과 ptr2의 변수 값이 대입되고, 두번째 함수 내부 과정에서 swap이 일어나면서 p1값과 p2값이 서로 바뀐다. 이는 곧, 세번째 과정인 참조 대상이 서로 바뀐다는 것을 뜻한다.

※ 중요한 건, 여전히 ptr1과 ptr2는 num1과 num2를 가리킨다는 점. 변화 없다. ※

 

★ 올바른 예시 - num1과 num2의 값이 서로 바뀐다. ★

: 올바르게 num1과 num2 변수값이 서로 바뀌게 하기 위해서는 ptr1과 ptr2의 값이 서로 바뀌어야 한다. 즉, p1과 p2가 num1과 num2를 가리키게 해서는 안되고 p1과 p2가 ptr1과 ptr2를 가리키게 하기 위해 더블포인터로 만들어야 한다.

#include <stdio.h>

void SwapIntPtr(int **dp1, int **dp2){
  int * temp = *dp1;
  *dp1 = *dp2;
  *dp2 = temp;
}

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

  SwapIntPtr(&ptr1, &ptr2);
  printf("*ptr1, *ptr2: %d %d\n", *ptr1, *ptr2);

  return 0;
}
/*
*ptr1, *ptr2: 10 20
*ptr1, *ptr2: 20 10
*/

 

: 더블포인터 dp1과 dp2가 각각 ptr1과 ptr2를 가리킨다. dp1을 가리키는 ptr1에 저장된 값과 dp2를 가리키는 ptr2에 저장된 값이 서로 바뀌는 swap 과정이 발생하므로, ptr1에는 num2의 주소값이 들어가고, ptr2에는 num1의 주소값이 들어간다. 따라서 *ptr1과 *ptr2의 값이 서로 바뀜을 확인할 수 있다.

 

 

 

 

 

 

 

18. 다차원 배열과 포인터의 관계

 

⑦⑧⑨⑩⑪⑫⑬⑭⑮
⑯⑰⑱⑲⑳

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

---

* 출처 <윤성우 열혈 C 프로그래밍>