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

🫡 네번째 포스팅부터는 C언어 심화 개념을 본격적으로 나간다! 점점 흥미있어지는 C언어! 두 번째 파트 11장부터 15장까지 정리했다.

---

11. 1차원 배열

① 배열이란?

→ 다수의 데이터를 저장하고 처리하는 경우 유용하게 사용할 수 있는 것. 여러 개의 변수를 저장할 필요 없이, 한 번에 많은 수의 변수 선언 및 저장 가능!

 

② 1차원 배열 선언 & 접근

→ 필요한 것: 배열이름, 자료형, 길이정보

 

ex) int arr1[7];

: int형 변수 4개로 이루어진 배열을 만들고, 그 배열의 이름은 arr1로 한다는 뜻이다. int형 변수 4개가 나란히 선언되었고, 실제로 배열을 이루는 요소들(변수들)의 주소 값을 확인 해보면 나란히 배치되어 있다.

 

ex) float arr2[10]; double arr3[12];

 

→ 접근하기 위해서는 [] 연산자를 사용하고 예를 들어 arr[idx] = 20; 이라는 코드는 배열 arr의 idx+1 번째 요소에 20을 저장한다는 뜻이다. []안에 들어가는 숫자를 index(인덱스 값)라 하고, 이 때 첫 번째 요소를 지칭할 때 사용되는 숫자가 1이 아니라 0이다.

 

ex)

#include <stdio.h>

int main(void) {
  int arr[5];
  int sum = 0, i;

  arr[0] = 10, arr[1] = 20, arr[2] = 30, arr[3] = 40, arr[4] = 50;

  for(i=0;i<5;i++){
    sum += arr[i];
  }

  printf("total in arr is %d\n",sum);
  return 0;
}

 

→ 따라서, 배열의 모든 요소는 반복문을 이용해서 순차적으로 접근하는 것이 가능하다. 다수의 변수를 선언이 아니라, 반복문 기반으로 순차적 접근이 가능하다.

→ 만약, 배열의 길이가 3인 배열인데 4번째 요소의 접근을 시도한다면 컴파일 에러가 나지 않는다. 따라서 더 주의. 할당하지 않은 메모리 공간을 침범하는 문제점 발생(위 예제에서 i가 5까지 진행되게 하고 합계를 구하면 매우 큰 숫자가 나옴)

 

③ 배열의 선언과 동시에 초기화 / 배열의 길이, 바이트 단위의 배열 크기

(1) int arr1[5] = {1, 2, 3, 4, 5};

(2) int arr2[] = {1, 2, 3, 4, 5, 6, 7}; (컴파일러가 초기화 리스트의 수를 자동 참조하여 길이정보를 채워준다 - 배열의 길이 정보 생략 가능)

(3) int arr3[5] = {1, 2}; (첫번째 요소부터 순차적으로 값을 채워나가되 채울 값이 존재하지 않는 요소들은 0으로 채워진다)

 

ex)

#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};
  int ar1Len, ar2Len, ar3Len, i;

  printf("the size of arr1: %d\n",sizeof(arr1));
  printf("the size of arr2: %d\n",sizeof(arr2));
  printf("the size of arr3: %d\n",sizeof(arr3));

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

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

/*
the size of arr1: 20
the size of arr2: 28
the size of arr3: 20
1 2 3 4 5 
1 2 3 4 5 6 7 
1 2 0 0 0
*/

 

→ 배열의 길이를 구하고 싶다면 바이트 단위의 배열 크기를 바이트 사이즈로 나눈다면 배열의 길이를 구할 수 있다.

 

ex) 길이가 5인 int형 배열 선언 - 5개의 정수 입력받기. 입력이 끝나면, 입력된 정수 중 최댓값, 최솟값, 입력된 정수의 총 합 출력

(이 때, 배열 대상으로 scanf 입력받을 때도 &arr[2]로 앞에 &표시를 붙여주어야 한다)

#include <stdio.h>

int main(void) {
  int arr[5];
  int sum = 0;
  int max, min;

  printf("enter 5 numbers in arr: ");
  for(int k = 0; k < 5; k++){
    scanf("%d",&arr[k]);
    sum += arr[k];
    if(k==0){
      max=arr[0];
      min=arr[0];
    }
    else{
      if(arr[k] > max){
      max = arr[k];
      }
    if(arr[k] < min){
      min = arr[k];
    }
    }
    
  }

  printf("sum: %d, max: %d, min: %d\n",sum,max,min);
  
  return 0;
}

 

ex) char형 1차원 배열을 선언과 동시에 "Good time" 문장의 내용으로 초기화, 초기화 이후에는 저장된 내용을 출력

#include <stdio.h>

int main(void) {
  char sentence[] = "Good time";

  for(int i = 0; i < sizeof(sentence)/sizeof(char); i++){
    printf("%c",sentence[i]);
  }
  printf("\n");
  return 0;
}

 

④ char형 배열

→ 변수형태의 문자열 배열 선언을 만들면 문자열의 저장과 변경도 가능

ex) char str[] = "Good morning!";

 

→ 위와 같이 배열을 만들면 배열의 길이는 14로, 문자열의 끝에는 '\0'이라는 특수문자(escape sequence)가 자동으로 삽입된다. 문자열의 끝에 자동으로 삽입되는 문자 '\0'을 가리켜 null 문자라고 한다. 

 

ex) 예시

#include <stdio.h>

int main(void) {
  char str[] = "Good morning!";

  printf("size of an array: %d\n",sizeof(str));
  printf("null char: %c\n",str[13]);
  printf("null char: %d\n",str[13]);

  str[12] = '?';
  printf("after revision: %s\n",str);
  return 0;
}

 

→ 위 예시와 같이 null은 정수형으로 ASCII code 값이 0이 된다. (공백문자라면 ASCII code가 32)

→ null도 공백문자도 %c로 표현하면 모두 똑같이 표현되기에 주의!

 

ex) 예시 - null문자가 존재하는 문자열과, null문자가 존재하지 않는 문자 배열

#include <stdio.h>

int main(void) {
  char sentence1[] = "Good time";
  char sentence2[] = {'G','o','o','d',' ','t','i','m','e'};

  int sentence1Len, sentence2Len;
  
  sentence1Len = sizeof(sentence1) / sizeof(char);
  sentence2Len = sizeof(sentence2) / sizeof(char);
  
  printf("sentence 1's length is: %d, sentence2's length is %d\n",sentence1Len,sentence2Len);
  //sentence 1's length is: 10, sentence2's length is 9
  printf("\n");
  return 0;
}

 

⑤ scanf 함수의 입력: %s 서식문자 사용

→ 문자열을 이용한 scanf는 &표시를 사용하지 않고, 한 번 scanf를 사용하면 공백 기준 문자열을 여러 개 나누므로 첫번째 문자열만 출력된다. scanf는 데이터를 구분짓는 기준이 공백이므로, 문장 전체를 입력받기에는 적절치 않다. 

→ scanf 함수호출을 통해서 입력 받은 문자열의 끝에도 null 문자가 삽입되어 있다. (C언어에서 표현하는 모든 문자열의 끝에는 null 문자 자동 삽입)

→ 따라서 마지막에 null 문자가 존재하지 않으면 문자배열이고, null 문자가 있다면 문자열이다. 

 

ex)

#include <stdio.h>

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

  printf("enter the string: ");
  scanf("%s", str);
  printf("what you entered: %s\n",str);

  while(str[idx]!=0){
    printf("%c", str[idx]);
    idx++;
  }
  print("\n");
  return 0;
}

 

⑥ null문자

→ 문자열 구분 용도

→ char str[100] = " . . . "; 코드에서 str[0]이 문자열의 시작위치이며, 문자열의 끝에는 null 문자 삽입

→ 문자열 도중에 null을 추가한다면 %s 형태로 printf() 진행할 경우 null까지의 한 개의 문자열로 인식하고, 인식한 문자열만 출력

 

ex) 하나의 영단어를 입력받고, 입력받은 영단어의 길이 계산

#include <stdio.h>

int main(void) {
  char str[100];
  int idx = 0, cnt = 0;

  printf("enter your word: ");
  scanf("%s", str);

  while(str[idx]!=0){
    cnt++;
    idx++;
  }
  printf("%d\n",cnt);
  return 0;
}

 

ex) 영단어 입력받고 char형 배열에 저장, 배열에 저장된 영단어를 역순으로 뒤집음. null문자의 위치를 변경해서는 안된다. 뒤집은 영단어 출력하기

 

- 풀이 (1) 먼저 입력한 단어의 길이를 while문으로 알아낸 뒤, 첫 for문으로 새로운 배열에 거꾸로 저장, 두 번째 for문으로 새로운 배열 출력

#include <stdio.h>

int main(void) {
  char str[100];
  char str2[100];
  int length=0, idx;

  printf("enter your word: ");
  scanf("%s", str);

  while(str[length] != 0){
    length++;
  }
  idx = length-1;
  for(int j = 0; j < length; j++){
    str2[j] = str[idx];
    idx--;
  }

  for(int k = 0; k < length; k++){
    printf("%c",str2[k]);
  }
  
  printf("\n");
  return 0;
}

 

- 풀이 (2) while문으로 영단어의 길이를 파악한 뒤, for문으로 영단어 길이의 절반까지 진행하며 앞과 뒤를 서로 바꿈 (temp 변수 사용)

#include <stdio.h>

int main(void) {
  char voca[100];
  int len = 0, i;
  char temp;

  printf("enter your word: ");
  scanf("%s",voca);

  while(voca[len] != '\0')
    len++;

  for(int i = 0; i < len/2; i++){
    temp = voca[i];
    voca[i] = voca[(len-i)-1];
    voca[(len-i)-1] = temp;
  }

  printf("after reversing... %s\n",voca);
  return 0;
}

 

ex) 영단어를 입력받고, 입력받은 영단어를 구성하는 문자 중에서 아스키 코드의 값이 가장 큰 문자를 찾아서 출력(예를 들어 LOVE를 입력했다면 V 출력)

#include <stdio.h>

int main(void) {
  char word[100];
  printf("your word: ");
  scanf("%s",word);

  char max = 0;
  int idx = 0;
  while(word[idx] != 0){
    if(word[idx] > max){
      max = word[idx];
    }
    
    idx++;
  }

  printf("%c\n",max);
  
  return 0;
}

12. 포인터의 이해

⑦ 포인터 변수 - 주소 값의 저장

→ 포인터를 이용해서 메모리에 직접 접근이 가능하다

 

ex) 아래의 코드가 있다면,

#include <stdio.h>

int main(void) {
  char ch1 = 'A', ch2 = 'Q';
  int num = 7;
  return 0;
}

 

→ char 데이터 타입은 1바이트, int 데이터 타입은 4바이트로 실제 메모리에 위와 같이 배치되어 있다. (꼭 연속적으로 배치되어 있는 건 x)

→ 이 때, 1 byte 별로 메모리 주소가 할당이 되는데, 각 byte 별의 메모리 주소값 자체는 정수이며 해당 정수를 변수로 저장하기 위해 마련된 개념이 '포인터 변수'

→ 이 때, 1바이트를 넘어갈 경우 변수가 어디에 할당되어 있는 지 알려면 시작번지만을 가지고 위치를 표현

ex) 위 int형 변수 num은 0x12ff75번지에 할당되어 있다.

 

→ 포인터 변수를 만들기 위해서는 * 표시를 사용

ex) int * pnum;

≫ pnum은 포인터 변수의 이름

≫ int *은 int형 변수의 주소 값을 저장하는 포인터 변수를 선언

 

ex) pnum = #

≫ 위 예시에서 &연산자는 & 오른쪽에 등장하는 피연산자의 주소 값을 반환하는 연산자이다. & 연산의 결과로 위 예시에서는 num의 주소값이 반환되며, 이를 포인터 변수 pnum에 저장하게 된다.

≫ 따라서, 위 그림처럼 pnum에 num의 주소값이 저장된다. 이를 "포인터 변수 pnum이 int형 변수 num을 가리킨다"라고 표현

≫ 여기서 포인터 변수의 크기는 4byte 또는 8byte 가능하다. 32bit system에서는 4byte, 64bit system에서는 8byte로 표현한다. 각 bit system에서 표현하는 주소 값의 크기에 따라 포인터 변수의 크기가 달라진다. (당연히 주소 값의 크기 = 포인터 변수의 크기)

 

⑧ 포인터 변수의 선언 / 포인터 형(Type)

→ type * ptr; 즉, type형 변수의 주소 값을 저장하는 포인터 변수 ptr의 선언

ex) int num = 7; int * pnum = #에서 int * pnum을 통해 우리는 pnum이 가리키는(즉, pnum이라는 주소값을 가지는) 변수 num의 자료형이 int임을 알 수 있다.

→ 따라서, 포인터 변수의 선언 형태만 보고도, 포인터가 현재 가리키는 변수의 자료형 짐작 가능

 

→ int *, char *, double * 등을 가리켜 포인터 형(type)이라 한다. 

 

⑨ & 연산자  / * 연산자

→ & 연산자는 피연산자의 주소값을 반환하는 연산자. &연산자의 피연산자는 변수여야 하며, 상수는 피연산자가 될 수 없다. 

→ * 연산자는 포인터가 가리키는 메모리 공간에 접근할 때 사용하는 연산자. 즉 예를 들어 *pnum이라면 pnum이라는 포인터 변수가 가리키는 변수를 뜻한다.

 

ex) *연산자를 이용해서 num 변수에 저장한 값을 10에서 20으로 바꾸었다.

#include <stdio.h>

int main(void) {
  int num = 10;
  int *pnum = &num;
  *pnum = 20;
  printf("%d\n",num); //20
  return 0;
}

 

ex) pnum int형 포인터 변수를 선언하고 두 변수 각각의 주소가 되어 변수의 값을 바꾸었다.

#include <stdio.h>

int main(void) {
  int num1 = 100, num2 = 100;
  int *pnum;

  pnum = &num1;
  (*pnum)+=30;

  pnum = &num2;
  (*pnum)-=30;

  printf("num1: %d, num2: %d\n",num1, num2); //num1: 130, num2: 70
  return 0;
}

 

⑩ 다양한 포인터 형

→ pnum이 int형 변수라면 "pnum에 저장된 주소를 시작으로 4byte를 읽어 들여서 이를 정수로 해석"

→ pnum이 double형 변수라면 "pnum에 저장된 주소를 시작으로 8byte를 읽어 들여서 이를 실수로 해석"

 

→ 이렇게 포인터 형은 메모리 공간을 참조하는 기준이 된다. 포인터 형을 정의한 이유는 * 연산자를 통한 메모리 공간의 접근 기준 마련. 

→ 즉 * 연산자 앞에 포인터의 형을 만들어서, 포인터로 메모리 접근을 할 때, 해당 메모리에 대한 메모리 접근 공간을 참조할 수 있다.

 

ex) 한 개의 변수를 동시에 포인터로 가리키는 예제

#include <stdio.h>

int main(void) {
  int num = 10;
  int * ptr1 = &num;
  int * ptr2 = ptr1;

  (*ptr1)++;
  (*ptr2)++;
  printf("%d\n",num); //12
  return 0;
}

 

ex) int형 변수 num1과 num2를 선언과 동시에 각각 10과 20으로 초기화하고, int형 포인터 변수 ptr1과 ptr2를 선언하여 각각 num1과 num2를 가리키게 하자. 그리고 이 상태에서 포인터 변수 ptr1과 ptr2를 이용해서 num1의 값을 10 증가시키고, num2의 값을 10 감소시키자. 이제 두 포인터 변수 ptr1과 ptr2가 가리키는 대상을 서로 바꾸자. 즉 포인터 변수 ptr1이 num2를 가리키게 하고, 포인터 변수 ptr2가 num1을 가리키게 하자. 그리고 마지막으로 ptr1과 ptr2가 가리키는 변수에 저장된 값을 출력하자.

#include <stdio.h>

int main(void) {
  int num1 = 10, num2 = 20;
  
  int * ptr1 = &num1;
  int * ptr2 = &num2;
  
  (*ptr1)+=10; // num1 20
  (*ptr2)-=10; // num2 10

  int *temp;
  temp = ptr2;
  ptr2 = ptr1;
  ptr1 = temp;

  printf("ptr1 points to %d, ptr2 points to %d\n",*ptr1, *ptr2);
  printf("num1: %d, num2: %d\n",num1, num2);
  
  return 0;
}

/*
ptr1 points to 10, ptr2 points to 20
num1: 20, num2: 10
*/

 

⑪ 잘못된 포인터의 사용

#include <stdio.h>

int main(void) {
  //(1)
  int *ptr;
  *ptr = 200;

  //(2)
  int *ptr2 = 125;
  *ptr2 = 10;
  return 0;
}

 

(1) 포인터 변수를 선언만 했지만, ptr이 가리키는 위치를 지정하지 않았다. 이 때 메모리 어딘가에 200으로 바꾸어야 하는데, 컴퓨터 입장에서는 모른다.

(2) 포인터 변수를 역시 선언만 했지만, 125가 어디인지 모르므로 역시 메모리 위치를 모른다.

 

→ 포인터 변수를 선언만 해놓고 이후에 유효한 주소 값을 채워 넣는 다면 초기화를 아래와 같이 한다. 이를 null pointer라고 하며, 포인터 변수를 만들기는 했지만, 메모리 공간의 특정 공간 어디를 가리키는 건 아니다. 포인터 변수가 아직 아무데도 가리키지 않는다.

#include <stdio.h>

int main(void) {
  int *ptr1 = 0;
  int *ptr2 = NULL;
  return 0;
}

13. 포인터와 배열! 함께 이해하기

⑫ 배열의 이름 = 포인터

→ 앞서 배운 포인터는 변수 형태의 포인터 였다면, 배열의 이름은 상수 형태의 포인터이다. 값을 바꿀 수 없는 포인터

→ %p conversion specifier로 변수의 여러 포인터를 살펴보자면,

#include <stdio.h>

int main(void) {
  int arr[3] = {0, 1, 2};
  printf("name of the array: %p\n",arr);
  printf("first element: %p\n", &arr[0]);
  printf("second element: %p\n", &arr[1]);
  printf("third element: %p\n",&arr[2]);
  return 0;
}
/*
name of the array: 0x7ffe7b9854a0
first element: 0x7ffe7b9854a0
second element: 0x7ffe7b9854a4
third element: 0x7ffe7b9854a8
*/

 

→ 배열의 이름 자체가 배열의 포인터가 되고, 즉 배열의 첫번째 요소의 주소이며, '값의 저장이 불가능한 상수'라는걸 출력 결과로 알 수 있다.

→  또한, int형 배열요소간 주소 값의 차는 4바이트임을 알 수 있고, 이는 곧 '모든 배열 요소가 메모리 공간에 나란히 할당된다' 증명 가능

 

* 앞서 배운 변수를 가리키는 포인터는 '변수 형태의 포인터'로 다른 변수를 가리킬 수 있지만, 배열을 가리키는 포인터는 '상수 형태의 포인터'로 다른 배열을 가리킬 수 없다. (상수이므로 바꾸기 불가능!)

 

ex) int arr1[5]; 라면, 배열의 이름 arr1이 가리키는 것은 배열의 첫번째 요소이며, 이는 int형 변수이다. 따라서 arr1은 int형 포인터(int *)라는 결론이 나온다.

 

→ 즉 1차원 배열의 포인터 형은 배열의 이름이 가리키는 대상을 기준으로 결정한다 (변수 형태의 포인터와 동일!)

 

ex) 배열을 가리키는 상수 형태의 포인터 → * 연산

→ 아래 예시를 통해 배열 이름 자체가 배열의 포인터이므로 배열 이름을 사용해 각 배열의 첫번째 원소를 바꾸었다.

#include <stdio.h>

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

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

 

→ 즉, 앞서 언급한 배열 이름 arr을 사용해 arr[0], arr[1], arr[2] arr[2] 모두 arr이라는 배열 이름의 포인터를 이용해 배열에 접근하여 각각의 배열 내의 원소를 가져올 수 있었던 것이다. 한 번 더 생각해보면, 배열의 첫번째 원소 주소를 ptr 포인터 변수에 따로 저장해 ptr 포인터 변수로도 arr처럼 접근이 가능하다는 점이다! 아래 예제 확인해보자

 

ex) 배열 이름 arr처럼 ptr 변수로 배열 원소들 접근해보기

#include <stdio.h>

int main(void) {
  int arr[3] = {15, 25, 35};
  int *ptr = &arr[0];

  printf("%d %d\n", ptr[0], arr[0]); // 15 15
  printf("%d %d\n", ptr[1], arr[1]); // 25 25
  printf("%d %d\n", ptr[2], arr[2]); // 35 35
  printf("%d %d\n", *ptr, *arr); // 15 15

  return 0;
}

 

⑬ 포인터 연산

→ 포인터 변수를 대상으로 다양한 형태의 증가 및 감소연산을 진행할 수 있다.

 

ex) int* 형과 double* 형 포인터 변수의 산술연산 결과 예제를 아래 살펴보면

#include <stdio.h>

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

  printf("%p %p\n",ptr1+1, ptr1+2);
  printf("%p %p\n",ptr2+1, ptr2+2);

  printf("%p %p\n",ptr1,ptr2);
  ptr1++;
  ptr2++;
  printf("%p %p\n",ptr1,ptr2);
  return 0;
}

: ++가 진행될때마다 int형 포인터에 저장된 주소값은 4씩 증가하고, double형 포인터에 저장된 주소값은 8씩 증가한다.

 

→ 따라서 int형 포인터를 대상으로 n 증가하면 nxsizeof(int)의 크기만큼 증가하고, double형 포인터를 대상으로 n 증가하면 nxsizeof(double)의 크기만큼 증가한다. (감소도 마찬가지)

 

ex) ptr 포인터의 증가연산자 / 감소연산자에 따라 가리키는 주어진 배열의 원소가 계속 바뀜을 아래로 확인할 수 있다!

#include <stdio.h>

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

  printf("%d ",*ptr); ptr++;
  printf("%d ",*ptr); ptr++;
  printf("%d ",*ptr); ptr--;
  printf("%d ",*ptr); ptr--;
  printf("%d ",*ptr); printf("\n"); // 11 22 33 22 11
  return 0;
}

 

→ 위 그림과 같이 int * 형 포인터라면 + 1 씩 증가할 때마다 실제로는 int가 4byte이므로 주소값이 4(10진법)씩 증가한다. (그 다음 원소를 가리키기 위해서) / 똑같은 방식으로 double *형 포인터라면 주소값이 8(10진법)씩 증가한다

 

(+) *(++ptr) = 20;이나 *(ptr+1) = 20; 모두 현재 ptr이 가리키는 위치에서 4바이트 떨어진 메모리 공간에 20을 저장하는 코드(int * 형 포인터) 하지만 ptr+1의 경우 ptr 값 자체가 바뀌지는 않는다는 차이만 있다.

 

→ 따라서 arr[i]은 *(arr+i)와 같다고 말할 수 있다. 

 

ex) 길이가 5인 int형 배열을 1, 2, 3, 4, 5로 초기화. 배열의 첫번째 요소를 가리키는 포인터 변수 ptr 선언. 포인터 변수 ptr에 저장된 값을 증가시키는 형태의 연산을 기반으로 배열요소에 접근하면서 모든 배열요소의 값을 2씩 증가시키고, 확인

#include <stdio.h>

int main(void) {
  int arr[5] = {1,2,3,4,5};
  int * ptr = arr;

  for(int i = 0; i < 5; i++){
    (*ptr) += 2;
    ptr++;
  }

  for(int j = 0; j < 5; j++){
    printf("%d ", arr[j]);
  }

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

 

ex) 위 예제에서 포인터 변수 ptr에 저장된 값을 변경시키지 않고, ptr을 대상으로 덧셈연산을 하여, 그 결과로 반환되는 주소 값을 통해서 모든 배열요소에 접근하여 값을 2씩 증가

#include <stdio.h>

int main(void) {
  int arr[5] = {1,2,3,4,5};
  int * ptr = arr;

  for(int i = 0; i < 5; i++){
    *(ptr+i) += 2;
  }

  for(int j = 0; j < 5; j++){
    printf("%d ", arr[j]);
  }

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

 

ex) 위 배열의 마지막 요소를 가리키는 포인터 변수 ptr 선언. 그 다음, 포인터 변수 ptr에 저장된 값을 감소시키는 형태의 연산을 기반으로 모든 배열요소에 접근하여 배열에 저장된 모든 정수를 더하여 그 결과를 출력하기

#include <stdio.h>

int main(void) {
  int arr[5] = {1,2,3,4,5};
  int * ptr = &arr[4];
  int ans = 0;

  for(int i = 0; i < 5; i++){
    ans += *ptr;
    ptr--;
  }

  printf("%d", ans);

  printf("\n"); //15
  return 0;
}

 

ex) 길이가 6인 int형 배열 arr 선언하고 1, 2, 3, 4, 5, 6으로 초기화한 다음, 배열에 저장된 값의 순서가 6, 5, 4, 3, 2, 1이 되도록 변경. 단, 배열의 앞과 뒤를 가리키는 포인터 변수 두 개를 선언해서 이를 활용하여 저장된 값의 순서를 뒤바꾸기.

#include <stdio.h>

int main(void) {
  int arr[6] = {1,2,3,4,5,6};
  int *ptr1 = arr;
  int *ptr2 = &arr[5];
  int length = sizeof(arr)/sizeof(int);
  for(int i = 0; i < length/2 ; i++){
    int temp;
    temp = *ptr1;
    *ptr1 = *ptr2;
    *ptr2 = temp;

    ptr1++;
    ptr2--;
  }

  for(int j = 0; j < length; j++){
    printf("%d ",arr[j]);
  }
    
  printf("\n");
  return 0;
}
// 6 5 4 3 2 1

 

⑭ 상수 형태/ 변수 형태의 문자열을 가리키는 상수 형태/ 변수 형태의 포인터

(1) char str1[] = "My String";

(2) char *str2 = "My String";

 

→ (1)은 변수 형태의 문자열을 가리키는 상수형태의 포인터이다. 상수형태의 포인터는 위 배열의 이름으로 str1을 뜻하므로, str1 자체는 계속 문자 M을 가리키고만 있는 포인터 변수이다. 하지만 str1이 가리키는 내용은 str1[0] = 'K' 코드를 통해 얼마든지 변경할 수 있다.

→ (2) 상수 형태의 문자열을 가리키는 변수형태의 포인터이다. 변수형태의 포인터이므로 위 str2는 문자 M뿐만 아니라 다른 문자도 얼마든지 가리킬 수 있다. 

→ (1)(2) 모두 문자열의 첫번째 문자 M을 가리킨다는 공통점이 있다.

 

ex) str2가 다른 문자열을 가리키게 할 수 있고 / str1만 가리키는 문자열의 첫번째 원소를 바꿀 수 있다.

#include <stdio.h>

int main(void) {
  char str1[] = "My String";
  char *str2 = "My String";

  printf("%s, %s\n",str1, str2);

  str2 = "Your String";
  printf("%s, %s\n",str1, str2);

  str1[0] = 'W';
  str2[0] = 'W';
  printf("%s, %s\n",str1, str2);
  return 0;
}

 

→ 큰 따옴표로 묶여서 표현되는 문자열(상수 형태의 문자열)은 메모리 공간에 저장된 후 자동으로 메모리의 주소값이 반환된다. 따라서 예를 들어 printf()안에 상수 형태의 문자열을 넣었을 경우 printf() 함수는 정확히 말하면 문자열을 통째로 전달받지 않고, 문자열의 주소값을 전달받는 함수이다. 따라서 printf()에 실제로 전달되는 값은 문자열의 첫번째 문자 주소가 전달된다. 

 

⑮ 포인터 배열

→ 포인터 배열은 말 그대로 포인터 변수로 이루어진, 주소 값의 저장을 한 번에 할 수 있는 배열을 뜻한다.

 

ex) int 포인터를 저장한 포인터 배열

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

 

ex) 문자열을 저장하는 포인터 배열

: 문자열 주소를 저장하는 strArr 포인터 배열에는 각각의 문자열이 들어가는게 아니라, 문자열이 들어가면 자동으로 문자열의 주소가 각각 원소로써 저장이 된다고 할 수 있다.

#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;
}
/*
Simple
String
Array
*/

14. 포인터와 함수에 대한 이해

⑯ 인자전달의 기본방식은 값의 복사

→ 함수호출 시 전달되는 인자의 값은 매개변수에 복사가 된다. 즉, 함수가 호출될 때 실제로 전달되는 인자는 매개변수에 저장된 값이다.

 

ex) int SimpleFunc(int num) { } / SimpleFunc(age)

→ 위 코드가 있다면 age자체가 SimpleFunc()에 전달되는 것이 아니라, age에 저장된 값이 전달되어 매개변수 num에 복사된다.

 

⑰ 배열을 함수의 인자로 전달

→ 배열의 경우 배열 전체를 함수 인자로 전달할 수 없고, 메모리에 저장된 배열의 위치인 주소를 인자로 전달해서 이를 통해서 접근하도록 유도할 수 있다. 

 

ex) ShowArayElem()이라는 함수를 만들고 인자로 param 배열 변수 형태의 포인터를 가져와 배열의 원소를 함수 내에서 출력

#include <stdio.h>

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

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

 

ex) 함수를 추가로 만들어서 배열에 저장된 원소를 차례대로 값의 크기를 늘릴 수 있다.

#include <stdio.h>

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

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

int main(void) {
  int arr[3] = {1,2,3};
  AddArayElem(arr, sizeof(arr)/sizeof(int), 1);
  ShowArayElem(arr, sizeof(arr)/sizeof(int));

  AddArayElem(arr, sizeof(arr)/sizeof(int), 2);
  ShowArayElem(arr, sizeof(arr)/sizeof(int));

  AddArayElem(arr, sizeof(arr)/sizeof(int), 3);
  ShowArayElem(arr, sizeof(arr)/sizeof(int));
  return 0;
}

/*
2 3 4 
4 5 6 
7 8 9
*/

 

→ 따라서 배열의 주소 값만 안다면 어디서든 배열에 접근하여 저장된 값을 참조하고 배열의 원소를 직접 변경할 수도 있다.

 

→ 추가로 매개변수로 배열의 포인터를 전달할 때, int *param을 인자로 설정하기도 하지만, 표현으로 int param[]도 가능하다! 완전히 동일한 선언이나 후자 int param[]을 더 많이 사용하므로 기억하기(인자 전달에만 가능한 표현)

 

⑱ Call-by-value & Call-by-reference

 

(1) Call-by-value: 값을 전달하는 형태의 함수호출

ex) Swap 예시 - 값을 전달할 떄 함수에 값 자체가 전달될 뿐 원래 변수가 전달되지 않으므로 원래 변수에 저장된 값은 안바뀜

#include <stdio.h>

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


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

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

 

(2) Call-by-reference: 주소 값을 전달하는 형태의 함수호출

→ 따라서, 직접 주소값을 이용해서 접근한다면 주소로 접근하기에 실제 num1과 num2 변수로 접근하므로 Swap 가능

 

ex) call-by-reference를 이용해 주소값으로 실제 swap이 된 예시

#include <stdio.h>

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


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

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

 

→ 따라서 scanf 함수도 call-by-reference 형태의 함수호출로, 값을 입력받아서 변수에 그 값을 채우는 기능을 한다. 이 때 주소값을 입력해야 scanf의 입장에서 어디 변수에 채울 지, 메모리의 위치를 알게 되므로 함수에 & 주소를 반드시 채운다. / 문자열의 경우 & 연산자를 붙이지 않고 scanf에 전달한다. 문자열이 저장될 배열은 주소가 문자열 이름 자체이므로 &가 필요 x

 

ex) 변수 num에 저장된 값의 제곱을 계산하는 함수를 정의하고, 이를 호출하는 main 함수 작성. 단 아래 두가지 형태로 함수를 정의해야 함

→ Call-by-value 기반의 SquareByValue 함수

→ Call-by-reference 기반의 SquareByReference 함수

SquareByValue 함수는 인자로 전달된 값의 제곱을 반환해야 하며, SquareByReference 함수는 정수가 저장되어 있는 변수의 주소 값을 인자로 받아서 해당 변수에 저장된 값의 제곱을 그 변수에 다시 저장해야 한다.

#include <stdio.h>

int SquareByValue(int n){
  return n*n;
}

void SquareByReference(int *ptr){
  (*ptr) = (*ptr)*(*ptr);
}

int main(void) {
  int num;
  printf("Enter num: ");
  scanf("%d",&num);

  printf("After Call-by-value: %d\n",SquareByValue(num));
  SquareByReference(&num);
  
  printf("After Call-by-reference: %d\n",num);
  return 0;
}

 

ex) 세 변수에 저장된 값을 서로 뒤바꾸는 함수. 함수의 이름이 Swap3라면 Swap3(&num1, &num2, &num3); 형태로 호출되어야 한다. 함수호출의 결과로 num1에 저장된 값은 num2에, num2에 저장된 값은 num3에, num3에 저장된 값은 num1에 저장되어야 한다.

#include <stdio.h>

void Swap3(int *ptr1, int *ptr2, int *ptr3){
  int temp;
  temp = *ptr3;
  *ptr3 = *ptr2;
  *ptr2 = *ptr1;
  *ptr1 = temp;
}

int main(void) {
  int num1, num2, num3;
  printf("Enter three nums: ");
  scanf("%d",&num1);
  scanf("%d",&num2);
  scanf("%d",&num3);

  Swap3(&num1, &num2, &num3);
  printf("After Swap: %d, %d, %d\n",num1, num2, num3);

  return 0;
}
/*
Enter three nums: 10 20 30
After Swap: 30, 10, 20
*/

 

⑲ const 선언

(1) 포인터 변수가 참조하는 대상의 변경을 허용하지 않는 const 선언 (const int *ptr)

*ptr이 상수화

→ 맨 앞에 const 키워드를 쓴다.

→ 만약, const int *ptr = # 이라면 ptr이 가리키는 대상을 바꿀 수 없다. 만약 *ptr = 30;이라고 하면 ptr이 num이 아닌 30을 가리키게 하였으므로, 오류 발생!

→ 주의) 위 예시 코드에서 num 자체의 값을 바꿀 수는 있다. 즉, *ptr이 상수화되므로, ptr을 이용해 접근한 결과를 바꿀 수 없다.

 

ex) 따라서 아래와 같이 num1을 가리키는 ptr이 num2를 가리킨다면 오류가 발생한다! 하지만 ptr이 가리키는 곳인 주소는 얼마든지 바꿀 수 있다.

#include <stdio.h>

int main(void) {
  int num = 20;
  int num2 = 30;
  const int * ptr = &num;
  ptr = &num2; // OK
  num++; // OK
  (*ptr)++; // ERROR
  printf("%d\n",*ptr);
  return 0;
}

 

(2) 포인터 변수의 상수화 (int * const ptr)

ptr이 상수화

→ const 선언은 포인터 변수 이름 앞에 올 수도 있다.

→ int *const ptr = # 이라면 포인터 변수 ptr 자체가 상수가 된다. 즉, 한 번 주소값이 저장되면 그 값의 변경이 불가능하다는 뜻. 즉, 한 번 가리키기 시작한 변수를 끝까지 가리켜야 한다는 뜻이다.

→ 즉, 포인터에 들어간 주소값은 변경이 불가능하다. 따라서, 포인터는 해당 메모리의 위치를 끝까지 가리키고, 메모리의 다른 곳을 가리킬 수 없다. 하지만, 메모리가 가리키는 곳의 내용을 변경할 수는 있다. 즉, 위 ptr에서 *ptr = 40으로 설정하면 num에 40이 저장된다.

 

ex) ptr이 가리키는 곳이 num이라는 것은 바꿀 수가 없다. 하지만, 가리키는 곳인 num의 내용을 바꿀 수는 있다. 아래 예시에서 20이었는데 40으로 바뀌었음을 확인할 수 있다. 또한 num 자체도 역시 바꿀 수 있지만, ptr이 가리키는 메모리 주소는 바꿀 수 없다.

#include <stdio.h>

int main(void) {
  int num = 20;
  int num2 = 30;
  int * const ptr = &num;
  *ptr = 40; /// OK
  num = 30; // OK
  ptr = &num2; // ERROR
  printf("%d\n",*ptr);
  return 0;
}

 

(3) const 두 개 모두 사용 (const int * const ptr)

ptr이 상수화 + *ptr도 상수화

→ *ptr로도 가리키는 곳의 내용을 바꿀 수 없고, ptr에 저장된 주소값도 바꿀 수 없다. 하지만, 만약 내가 가리키는 곳이 어떤 변수인지 안다면(예: num), num의 값은 얼마든지 바꿀 수 있다.

 

- 정리하면 -

※ ptr 앞에 const 선언을 붙이면 ptr이 가리키는 화살표의 방향을 바꿀 수 없고

※ int * ptr 앞에 const 선언을 붙이면 ptr이 가리키는 곳(*ptr 사용하면)의 내용을 바꿀 수 없다.

 

- 반대로 말하면 -

※ ptr앞에 const 선언을 붙이면 화살표만 고정이지, ptr이 가리키는 곳의 내용은 얼마든지 바꿀 수 있다.

※ int * ptr 앞에 const 선언을 붙이면 ptr이 가리키는 곳의 내용만 바꿀 수 없을 뿐, ptr이 얼마든지 메모리의 다른 곳을 가리키게 할 수 있다.

 

★ 화살표도 고정 / 가리키는 곳의 내용도 고정하려면 두 군데 모두 const 선언 필수 ★

 

⑳ const 선언의 의미

→ const 선언을 많이 하면 프로그램 코드의 안전성은 높아진다. 예를 들어, PI는 값이 변하면 안되는데 앞에 const 선언을 안붙이면 문제가 발생해도 컴파일러가 문제점을 발견할 수 없다.

 

ex) 아래 예제에서 매개변수 선언에서 매개변수 arr을 대상으로 const 선언을 한 이유?

void ShowAllData(const int* arr, int len){
  int i;
  for(i=0;i<len;i++)
    printf("%d ", arr[i]);
}

 

→ *arr이 고정이므로, 프로그래머가 실수로 ShowAllData() 함수 코드를 작성하는 과정에서 원래의 배열요소 내용을 실수로 바꿀 수 없게끔, 즉 원본 데이터를 바꾸지 않게 const 선언을 한 것이다.

 

ex) 아래의 예제에서 지적할만한 사항은?

#include <stdio.h>

void ShowData(const int *ptr){
  int *rptr = ptr;
  printf("%d \n",*rptr);
  *rptr = 20;
}

int main(void) {
  int num = 10;
  int *ptr = &num;
  ShowData(ptr);
  return 0;
}

 

→ const 선언으로 *ptr 값을 안바꾸게끔 설정하였는데, rptr을 또 만들어 *rptr값을 바꾸게끔 해서 const 선언이 소용이 없어졌다.

15. 도전! 프로그래밍 2

* 도전 1) 길이가 10인 배열을 선언하고, 총 10개의 정수를 입력 받아서, 홀수와 짝수를 구분 지어 출력하는 프로그램을 작성해 보자. 일단 홀수부터 출력하고 나서 짝수를 출력하도록 하자. 단, 10개의 정수는 main 함수 내에서 입력받도록 하고, 배열 내에 존재하는 홀수만 출력하는 함수와 배열 내에 존재하는 짝수만 출력하는 함수를 각각 정의해서 이 두 함수를 호출하는 방식으로 프로그램을 완성하자.

 

- 실행의 예 -

총 10개의 숫자 입력

입력: 1

입력: 2

입력: 3

입력: 4

입력: 5

입력: 6

입력: 7

입력: 8

입력: 9

입력: 0

홀수 출력: 1, 3, 5, 7, 9

짝수 출력: 2, 4, 6, 8, 0

#include <stdio.h>

void getOddNum(int *ptr,int len){
  printf("print odd numbers: ");
  int cnt = 0;
  for(int i = 0; i < len; i++){
    if ((*(ptr+i)) % 2 == 1){
      cnt++;
    }
  }
  for(int i = 0; i < len; i++){
    if ((*(ptr+i)) % 2 == 1){
      cnt--;
      printf("%d",*(ptr+i));
      if (cnt != 0){
        printf(", ");
      }
    }
  }
  printf("\n");
}

void getEvenNum(int *ptr,int len){
  printf("print even numbers: ");
  int cnt = 0;
  for(int i = 0; i < len; i++){
    if ((*(ptr+i)) % 2 == 0){
      cnt++;
    }
  }

  for(int i = 0; i < len; i++){
    if ((*(ptr+i)) % 2 == 0){
      cnt--;
      printf("%d",*(ptr+i));
      if (cnt != 0){
        printf(", ");
      }
    }
  }
  printf("\n");
}


int main(void) {
  printf("Enter 10 numbers\n");
  int arr[10];

  for(int i =0; i < 10; i++){
    printf("your number: ");
    scanf("%d",&arr[i]);
  }

  getOddNum(arr,sizeof(arr)/sizeof(int)); 
  getEvenNum(arr,sizeof(arr)/sizeof(int));
  
  return 0;
}

 

* 도전 2) 프로그램 사용자로부터 10진수 형태로 정수를 하나 입력 받은 다음, 이를 2진수로 변환해서 출력하는 프로그램

#include <stdio.h>

int main(void) {
  int num;
  int answer[1000];
  int i = 0;

  printf("decimal number: ");
  scanf("%d", &num);

  while (1) {
    answer[i] = num%2;
    i++;
    if((num/2) == 1){
      answer[i] = 1;
      break;
    }
    num = num/2;
  }

  for(int j = 0; j < (i+1); j++){
    printf("%d",answer[i-j]);
  }
  printf("\n");
  return 0;
}

 

* 도전 3) 길이가 10인 배열을 선언하고, 총 10개의 정수를 입력받는다. 단, 입력 받은 숫자가 홀수이면 배열의 앞에서부터 채워나가고, 짝수이면 뒤에서부터 채워나가는 형식으로 출력

#include <stdio.h>
int main(void) {
  printf("Enter 10 numbers\n");
  int arr[10];
  int ans[10];
  int start = 0, end = 9;

  for(int i = 0; i < 10; i++){
    printf("your number: ");
    scanf("%d",&arr[i]);

    if(arr[i]%2 == 1){
      ans[start] = arr[i];
      start++;
    }
    else{
      ans[end] = arr[i];
      end--;
    }
  
  }

  for(int i = 0; i < 10; i++){
    printf("%d ", ans[i]);
  }

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

 

* 도전 4) 회문인지 아닌지를 판단해서 그 결과를 출력하는 기능의 함수 정의. 구현의 편의를 위해서 대소문자까지 일치해야 회문 인정

#include <stdio.h>

int isPalindrome(char *word, int length){
  for(int i = 0; i < (length/2); i++){
    if((*(word+i)) != (*(word+(length-1)-i))){
      return 0;
    }
  }
  return 1;
}

int main(void) {
  char word[10000];
  int length = 0;
  printf("enter your string: ");
  scanf("%s",word);

  while(word[length] != 0){
    length++;
  }
  if (isPalindrome(word,length) == 1){
    printf("this is palindrome\n");
  }
  else{
    printf("this is not a palindrome\n");
  }
  return 0;
}

 

* 도전 5) BubbleSort 내림차순 정렬 함수(DesSort; 배열을 인자로 전달) 만들기, 길이가 7인 int형 배열 선언: 7개의 정수 입력 받기. DesSort() 함수 이후 정렬된 배열의 요소 순서대로 출력하기

ex)

enter: 1

enter: 2

enter: 3

enter: 4

enter: 5

enter: 6

enter: 7

#include <stdio.h>

void DesSort(int param[], int len){
  int end = len - 1, start = 0;
  int * init = param;
  for(int k = 0; k < len; k++){
    start = 0;
    param = init;
    while(start < end){
      if(*param < *(param+1)){
        int temp;
        temp = *(param+1);
        *(param+1) = *param;
        *param = temp;
      }
      param++;
      start++;
    }
    end--;
  }
}

int main(void) {
  int arr[7];

  for(int i = 0; i < 7; i++){
    printf("enter: ");
    scanf("%d",&arr[i]);
  }

  DesSort(arr, sizeof(arr)/sizeof(int));

  for(int j = 0; j < 7; j++){
    printf("%d ",arr[j]);
  }
  printf("\n");
  return 0;
}

 

→ DesSort() 이렇게도 가능하다

void DesSort(int param[], int len){
  int a, b, temp;
  for(int a = 0; a < len; a++){
    for(int b = 0; b < (len-a); b++){
      if(param[b] < param[b+1]){
        temp = param[b+1];
        param[b+1] = param[b];
        param[b] = temp;
      }
    }
  }
}

---

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

* 위 포인터 변수 그림 1개 참조 https://pridiot.tistory.com/214

* 위 배열 포인터 그림 1개 참조 https://sejong-kr.libguides.com/c.php?g=942235&p=6822367