😎M.cloud☁️

- 버퍼 (buffer) : 컴퓨터의 양동이(연산 등 처리 전에 데이터를 잠시 보관)

- stdin(입력스트림) : 키보드입력을 처리하는 버퍼

- 개행문자(\n, 엔터)  : 입력을 종료하였으니 버퍼에 들어 있는 내용을 가지고 처리해라.

              └> 개행문자도 버퍼에 저장 함..

- scanf 함수는 '　' (스페이스), '\n' (엔터), '\t' (Tab) 을 만나기 전까지 stdin에서 데이터를 가져간 후 버퍼에서 삭제 함.

  ※ 입력을 받는 형과 계열이 다른경우에도 종료(ex. %d로 입력 받을 때 a를 입력되어있으면 읽어 오는 것 종료됨)

      처음부터 공백문자가 나타나면 형이 맞는 데이터가 나타날 때까지 입력을 계속 받음(엔터를 쳐도 안넘어감)

- %s는 stdin에 \n가 남아있더라도 실질적인 데이터(공백문자가 아닌 것들)이 나올때까지 입력을 받고,

  그 후에 공백문자에서는 종료.

- %c는 딱 하나의 문자데이터만 가져오기 때문에 stdin에 \n이 남아있으면 그것을 가져오고 종료됨.

  다른형식은 공백문자에 신경쓰지 않고 사용 가능하지만, %c는 버퍼에 남아있는 것을 잘 고려해야함.

| 문제의 해결 |

[ 버퍼 비우기 ] (gcc에서는 X)

fflush(stdin);

-> 버퍼를 비우는 것으로 사용했으나,

    표준으로 '무슨 역할을 한다'라고 정해진 것이 아님

    (Visual Studio 2015 부터는 표준을 따라서 버퍼를 비우는 작동 하지 않음)

[ getchar 함수 이용 ] : stdin에서 한 문자를 읽어와서 그 값을 리턴한다.

getchar();

 stdin에서 읽어진 문자는 stdin에서 삭제됨. fflush보다 잘 쓰일 수 있지만

아래와 같은 경우가 있을 수 있어 %c 사용을 자제하는게 최선

*결론, %c(문자) 대신 %s(문자열)을 입력받자!*

입력받은 값을 다른곳에 사용하지 않아서 알려주는 것.

컴파일 및 빌드는 다 정상적으로 됨.

https://modoocode.com/29

| 널 - 종료 문자열 (Null-terminated string) |

- 컴퓨터에서는 문자열을 char 형의 배열에 저장함.

- 문자열의 길이를 알아야 하는 문제 때문에 null 사용

  ※ 문자열에는 null이 들어갈 공간이 있어야 하기 때문에 (글자수 + 1)칸이 필요함

- 사용자 : "문자열을 출력해"▷컴퓨터 '널이 나올때까지 출력해야지.'

- 널 표현 : 0  : 널의 아스키값

                 '\0'  : 문자 0과 구분하기 위해서 \ 씀

                 (char)NULL  : NULL은 0이라고 정의 되어 있는 상수임(모두 대문자로 써야함)

#include <stdio.h>
int main() {
    char sentence_1[4] = {'A', 'b', 'c', '\0'};
    char sentence_2[4] = {'A', 'b', 'c', 0};
    char sentence_3[4] = {'A', 'b', 'c', (char)NULL};
    char sentence_4[4] = {"Abc"};

    printf("char sentence_1 : %s \n", sentence_1);  //%s를 통해서 문자열을 출력한다.
    printf("char sentence_2 : %s \n", sentence_2);
    printf("char sentence_3 : %s \n", sentence_3);
    printf("char sentence_4 : %s \n", sentence_4);

    return 0;
}

[문자열의 정의] NULL 문자를 위한 공간 하나를 더 추가하는 것 매우 중요함!!

- 한글자씩 작은 따옴표로 원소로 넣고, NULL을 마지막 원소로 넣거나

    ex) char sentence_1[4] = {'A', 'b', 'c', '\0'};
          char sentence_2[4] = {'A', 'b', 'c', 0};
          char sentence_3[4] = {'A', 'b', 'c', (char)NULL};

- 큰 따옴표로 문자 나열을 묶어 주기로 가능(이때 NULL은 뒤에 자동으로 추가 됨)

        ex) char sentence_4[4] = {"Abc"};

[문자열의 출력]

%c : 한문자만 출력

%s : 문자열을 출력(널이 나올때 까지 문자를 계속 출력)

|문자 개수 세기|

※ C에서 0은 거짓, 0이 아닌 모든 값은 참

    ex. while(str[i]) => str[i]의 값이 0이 될때 까지, null을 가리킬 때까지

| 함수 포인터 |

- 함수 포인터의 정의

함수의리턴형 (*포인터의 이름) (첫번째 인자의 형, 두번째 인자의 형...)

   └>주소값을 넣을 함수가 함수 포인터의 정의와 일치 하면 함수의 시작 주소값을 함수포인터에 넣을 수 있음.

- 함수의 이름이 함수의 시작 주소값을 나타냄

ex) 
	int (*pmax)(int, int);
	int max(int a, int b);

	pmax = max      // O 올바른 사용
	pmax = &max     // X 틀림

  └> pmax는 max와 동일하게 사용 하면 됨

다른 함수의 변수/배열의 값을 바꾸는 함수는 반드시 그 (변수/배열)타입을 가리키는 포인터를 인자로 가져야 한다.

        ※ 포인터가 아닌 인자는 다른 함수로 부터 값을 전달 받을 수만 있다.

| 함수의 원형 (prototype) |

- 사용 이유 : 보통 함수 정의는 main 함수 뒤에 넣는데,

  함수 사용 시 인자에 부적절한 타입의 변수를 사용하거나, 인자 누락 등이 발생 시 오류를 찾아내기 어렵다.

/* 함수의 원형 */
#include <stdio.h>

int swap(int *a, int *b);	// 이 것이 바로 함수의 원형

int main() {
  int i, j;
  i = 3;
  j = 5;
  printf("SWAP 이전 : i : %d, j : %d \n", i, j);
  swap(&i, &j);
  printf("SWAP 이후 : i : %d, j : %d \n", i, j);
  return 0;
}

int swap(int *a, int *b) {
  int temp = *a;
  *a = *b;
  *b = temp;
  return 0;
}

int swap(int *a, int *b);  ←함수의 원형

              └> 함수 원형의 의미 : 소스코드에서 사용되는 이 함수의 인자에 대한 정보를 제공 함

　　　　☞ 함수의 원형을 넣으면 함수 인자 사용에 문제가 있을 시, 정확히 알려줌

      　　　ex)

      　　　      error C2198: 'swap' : 호출에 매개 변수가 너무 적습니다.
      　　　      warning C4047: '함수' : 'int *'의 간접 참조 수준이 'int'과(와) 다릅니다.
      　　　      warning C4024: 'swap' : 형식 및 실제 매개 변수 2의 형식이 서로 다릅니다.

따라서, ★함수의 원형★을 반드시 집어 넣자.

| 함수의 시작 |

- 같은 작업을 하는 코드의 반복으로 복잡해지는 것을 줄일 수 있음

[ 함수의 정의 ]

#include <stdio.h>

int print_hello() {
  printf("Hello!! \n");
  return 0;
}
int main() {
  printf("함수를 불러보자 : ");
  print_hello();

  printf("또 부를까? ");
  print_hello();
  return 0;
}

- 함수 선언에서 int => 이 함수는 int 형의 정보를 반환한다. 는 뜻

   반환 : return => 여기서는 0(메모리의 4바이트 차지하는 int 형)

- 함수 이름의 조건 == 변수 이름의 조건

  좋은 함수의 이름 : 함수가 무슨 작업을 하는지 명확히 하는 것, 그 함수가 하는 작업을 설명해주는 이름을 정하는 것이 좋음

[ 함수의 몸체(body) ]

 : {} 안의 코드

[ 함수 호출(call) ]

 함수이름();

                  └>변수가 아니라 함수라는 뜻

[ 함수의 종료 ]

  . 함수를 호출하면 프로그램은 함수의 내용을 실행하고 원래 실행되려는 부분으로 돌아와 다음 명령으로 넘어감.
  . 함수 종료의 두 가지 형태 :  반환이 되어 종료, 함수의 끝 부분 까지 실행하여 종료

     (반환을 하여 종료되는 것이 안전함.)

★ return 을 실행하면 함수는 무조건 종료되어 함수를 호출하였던 부분으로 돌아간다. ★

[ 반환값 ]

함수를 호출하면 return값을 반환(출력) 함.

ex) 아래의 ret()함수의 반환값 : 1000

/* 반환값 */
#include <stdio.h>
int ret() { return 1000; }
int main() {
  int a = ret();
  printf("ret() 함수의 반환값 : %d \n", a);

  return 0;
}

※ function()을 코드 중간에 쓰는 것은 "함수 function의 반환값"을 뜻함.

| main 함수 |

- 프로그램을 실행할 때 컴퓨터가 main 함수 부터 찾음(모든 경우는 아님, 적어도 앞으로 만들게 될 C 프로그램들의 경우)

- 컴퓨터는 프로그램을 실행할 때 프로그램의 main 함수를 호출함으로써 시작함. 

- 만일 main 함수가 없다면 컴퓨터는 프로그램의 어디서 부터 실행할 지 모르게 되어 오류 생김

- main함수의 return은 OS가 받는다.

   ※ 보통 main함수는 0을 리턴하지만 다른값을 리턴해도 상관 없음. but 그 리턴값의 정보를 활용하는 일이 드묾.

| 함수의 인자 |

* 별개의 함수끼리는 다른 함수 안의 변수를 알 수도 사용할 수도 없음.

- 인자(argument, 혹은 매개변수(parameter))를 이용하면 가능

- 인자 사용 : 함수 정의 시, 괄호에 인자를 써둠

   반환값의타입 함수이름 (인자1의타입 인자1의이름, 인자2의타입 인자2의이름...) {}

#include <stdio.h>
int slave(int master_money) {
  master_money += 10000;
  return master_money;
}
int main() {
  int my_money = 100000;
  printf("2009.12.12 재산 : $%d \n", slave(my_money));

  return 0;
}

ex) 함수 정의 시,

int function( int a) {....} => "함수를 호출하는 코드로 부터 어떤 값을 a라는 int 형 변수에 인자(매개변수)로 받겠다."

      └ 인자가 있는 함수를 호출 할 때 인자의 값을 괄호안에 넣지 않거나 인자를 적게 넣으면 오류 남. ("함수 호출에 인자가 너무 적습니다.") 

*생각해보기 다시 해볼 것*

| 1차원 배열 가리키기 |

- arr++ : 오류 ('++'에 l-value가 필요합니다.)

  ∵ arr이 배열의 첫번째 원소를 가르키는 주소값 자체가 되는 것이지 포인터가아니기 때문에 불가능

| 포인터의 포인터 |

포인터 정의 int **p; =>int형 변수를 가르키는 포인터를 가르키는 포인터

*p : p라는 포인터에 있는 주소에 위치하고 있는 값(데이터)

| 배열 이름의 주소값 |

#include <stdio.h>

int main() {
  int arr[3] = {1, 2, 3};
  int (*parr)[3] = &arr;

  printf("arr[1] : %d \n", arr[1]);
  printf("parr[1] : %d \n", (*parr)[1]);
}

&arr : 크기가 3인 배열을 가리키는 포인터( ex. int (*p)[3];로 정의 )에 보관할 수 있다.

                                                                              └> () 없으면 int *p[3]; :크기가 int* 원소(포인터) 3개인 배열을 정의 한 것(포인터의 배열).

※ C언어에서는 배열의 시작점을 가르키는 포인터(arr)을 메모리에 따로 저장하지 않음-> 'arr'의 주소값은 없음. 

    (B언어 에서는 'arr'의 주소값을 따로 가졌음. 즉, arr과 &arr이 다른 값 출력됐음)

| 2차원 배열의 [ ] 연산자 |

- arr[ ][ ] (2차원 배열에서)

   arr[0] 의 값과 arr[0][0]의 주소값이 같고, arr[1] 의 값과 arr[1][0]의 주소값이 같음.

   값은 같으나 엄연히 다른 것. 암묵적으로 타입 변환시에 같은 포인터로 변환될 뿐임

- sizeof arr : 배열의 첫번째 원소를 가르키는 포인터로 변환되지 않음

int main() {
  int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
  printf("전체 크기 : %d \n", sizeof(arr));
  printf("총 열의 개수 : %d \n", sizeof(arr[0]) / sizeof(arr[0][0]));
  printf("총 행의 개수 : %d \n", sizeof(arr) / sizeof(arr[0]));
}

  sizeof(arr) : arr라는 배열의 전체 크기 = 원소 수 * 한 원소의 크기(32bit에서는 4byte)

  sizeof(arr[0]) : arr[0] 배열의 크기. 마치 일차 배열같이..(arr[0][0]~arr[0][3])

  sizeof(arr[0][0]) : 원소 arr[0][0]  1개의 의 크기 

  => sizeof 연산자로 배열의 크기를 알 수 있음

* 2차원 배열에서 arr[행의 개수][열의 개수];

- arr[0][0]의 형이 int이므로 이를 가르키는 주소 값이 되는 arr[0]은 int*형이 됨

  arr[1][0]의 형도 int이므로 이를 가르키는 주소 값이 되는 arr[1]역시 int*형 임.

- int** 형 포인터는 배열의 이름을 가리킬 수 없음,(가능하다면 int** 형 포인터로 배열의 원소에 접근 가능 하겠지...)

| 포인터의 형(type)을 결정짓는 두 가지 요소 |

*포인터를 통해 2차원 배열의 원소에 접근 하기 위해서는 배열의 '열의 갯수'에 대한 정보가 있어야함.

ex) arr[a][b]를 가르키는 포인터(parr)로 arr[x][y] 원소에 접근하는 것은 'arr + 4bx + 4y'와 같음.

따라서, 2차원 배열의 포인터는 열의 갯수에 대한 정보를 포함하여 아래와 같이

int (*parr)[3]; /* int형 이차원 배열을 가리키는데, 그 배열 한 행의 길이(열의 갯수)가 3임 */

배열의형 (*포인터이름)[2차원배열의 열 갯수]; 로 정의한다.

    => 여기서 parr은 열의 갯수가 3인 배열만 받을 수 있다. ex) arr[50][3] 가능, brr[50][2] 불가능

| 상수 포인터 ( int const * pa vs. int *const pa ) |

- 상수로 만들어 주는 'const'

★ 절대로 바뀌지 않을 것 같은 값에는 무조건 const를 붙여주는 습관을 기르자.

[ const *pa 와 *const pa ]

| 포인터의 덧셈, 뺄셈 |

- 포인터와 상수의 덧셈, 뺄셈 가능=> 주소값(가르키는 데이터의 형에 따라 다른)의 크기만큼 더하고 뺄셈 함

/* 과연? */
#include <stdio.h>
int main() {
  int a;
  char b;
  double c;
  int* pa = &a;
  char* pb = &b;
  double* pc = &c;

  printf("pa 의 값 : %p \n", pa);
  printf("(pa + 1) 의 값 : %p \n", pa + 1);
  printf("pb 의 값 : %p \n", pb);
  printf("(pb + 1) 의 값 : %p \n", pb + 1);
  printf("pc 의 값 : %p \n", pc);
  printf("(pc + 1) 의 값 : %p \n", pc + 1);

  return 0;
}

- 포인터 끼리의 덧셈은 허용X  ∵ 주소값 끼리의 덧셈은 의미가 없음

   └근데 포인터끼리의 뺄셈은 가능!! (why??)

- 포인터 대입 ex) pb = pa는 성립 하나, 두 포인터의 형이 같아야 함.

    └ 다르면 형변환 해야함 이건 나중에..

| 배열과 포인터와의 관계 |

배열의 저장 형태

배열의 시작부분을 가르키는 포인터를 정한 뒤에 포인터에 1을 더하면 다음 원소를 가리킬 수 있다.

∵ p + n => p가담고있는주소값 + n*4

=> 포인터에 정수를 더하는 것 만으로도 배열의 각 원소를 가리킬 수 있다.

     단항 연산자 *를 이용하여 원소들의 값을 불러오는 것도 가능

| 배열의 이름의 비밀 |

- 배열의 이름은 첫번째 원소의 주소값을 나타낼 수 있음

  ex) int arr[3] = {1, 2, 3};

        printf ("%d", arr);

        printf(%p", &arr[0]);

=> 같은 주소값이 출력됨. 하지만 배열의 이름이 포인터라는 것은 아님

　　배열의 이름 사용시 암묵적으로첫 번째 원소를 가리키는 포인터로 타입 변환될 뿐임.

| 배열은 배열이고 포인터는 포인터다 |

- sizeof(크기를 알려주는 연산자) 또는 &(주소값 연산자)와 쓰일 때는 배열의 이름으로 배열의 주소값을 나타낼 수 없음

#include <stdio.h>
int main() {
  int arr[6] = {1, 2, 3, 4, 5, 6};
  int* parr = arr;

  printf("Sizeof(arr) : %d \n", sizeof(arr));
  printf("Sizeof(parr) : %d \n", sizeof(parr));
}

의 결과는 

sizeof 배열 : 배열의 실제 크기

sizeof 배열포인터 : 포인터의 크기 (예시는 64비트 컴퓨터 이므로 포인터의 크기는 8)

=> 즉, 배열의 이름과 배열 첫번째 원소의 주소값은 다른 것.

| [ ] 연산자의 역할 |

/* [] 연산자 */
#include <stdio.h>
int main() {
  int arr[5] = {1, 2, 3, 4, 5};

  printf("a[3] : %d \n", arr[3]);
  printf("*(a+3) : %d \n", *(arr + 3));
  return 0;
}

의 결과는

즉, arr[i]은 *(arr + i)으로 바뀌어서 처리가 된다. ex) 3[arr] => *(3 + arr)도 가능하긴함. 헷갈려서 잘 안쓰는 형태임.

| 포인터의 정의 |

- 포인터 정의는 int* p; 또는 int *p; 모두 가능하나 다수의 포인터를 정의할 때 실수의 가능성이 있어 보통 후자의 형태로 씀

  실수의 예) int* p, q, r;  => 포인터 p와 int 변수 q, r를 선언

        　　　 int *p, *q, *r;  => 포인터 p, q, r를 선언

https://modoocode.com/24

| 포인터를 이해하기 앞서 |

- 32비트에서 작동하는 컴퓨터들은 주소값의 크기가 모두 32bit(4byte)임

  (64비트 컴퓨터에서는 64bit(8byte)

  : 32비트로 사용할 수 있는 주소값의 가지수는 2의 32승 byte(=4GB)

   즉, RAM은 최대 4GB까지 밖에 사용할 수 없음

| 포인터 | : 메모리 상에 위치한 특정한 데이터의 (시작)주소값을 보관하는 변수

- 포인터도 특정한 데이터를 보관하는 '변수'

                  └> 특정한 데이터가 저장된 주소값

  - 포인터도 형(type)이 있다 

    ☞ int형 데이터의 주소값을 저장하는 포인터 ≠ char형 데이터의 주소값을 저장하는 포인터

- 포인터의 정의 :

(포인터에 주소값이 저장되는 데이터의 형) *(포인터의 이름);

또는

(포인터에 주소값이 저장되는 데이터의 형)* (포인터의 이름);

ex) int *p;  또는 int* p;  

    ☞ p는 int형 데이터의 주소값을 저장하는 변수

| & 연산자 |

※ 연산자 & (AND)는 두개의 피연산자를 사용함

- 단항(unary) 연산자 : 피연산자가 1개인 연산자, AND와 다르게 해석됨

- 단항 & 연산자 : 피연산자의 주소값을 불러옴

&/* 주소값을 계산할 데이터 */

   ex) &a  : a의 주소값이 불려저옴.

/* & 연산자 */
#include <stdio.h>
int main() {
  int a;
  a = 2;

  printf("%p \n", &a);
  return 0;
}

의 결과

- a의 주소(포인터)를 16진수로 출력 %p (%d 로 출력시 10진수로 표기)

- 0x7fff80505b64 로 출력 되었지만 실제로는 주소값의 크기인 8바이트(16진수로 16자리)에서 0이 잘린것

  실제 주소값 : 0x00007fff80505b64

- 한번 정의 된 변수의 주소값은 바뀌지 않는다.

| * 연산자 | : 주소값에 대응되는 데이터를 가져오는 연산자

※ 곱셈 연산자 * 는 두개의 피연산자를 사용함

- 단항(unary) 연산자 : 피연산자가 1개인 연산자, 곱셈 연산과 다르게 해석됨

- 단항 * 연산자 : 주소값에 있는 데이터를 불러옴

ex)

/* * 연산자의 이용 */
#include <stdio.h>
int main() {
  int *p;
  int a;

  p = &a;
  a = 2;

  printf("a 의 값 : %d \n", a);
  printf("*p 의 값 : %d \n", *p);

  return 0;
}

  *p : 나(p)에 저장된 주소값에 위치한 데이터 즉, *p와 a는 동일함 

- 포인터 p 에 어떤 변수 a 의 주소값이 저장되어 있다면 '포인터 p 는 변수 a 를 가리킨다'라고 함.

- 포인터도 자기 자신만의 주소를 가지고 있음.

| 포인터에는 왜 타입이 있을까 |

- 포인터는 가리키는 변수의 주소값 전체의 정보가 아니라 주소값의 시작 정보만 가지고있기 때문에,

   포인터가 가르키는 변수의 형을 정해주지 않으면 *p했을 때 메모리에서 얼마만큼 읽어야 하는지 알 수 없기 때문

  ex)

int a;
int *p;
p = &a;
*p = 4;

 컴퓨터는 포인터 p 가 int * 라는 사실을 보고 이 포인터는 int 데이터를 가리키는 것을 알게 되어 시작 주소로 부터 정확히 4 바이트를 읽어 들어 값을 바꾸게 됨

| 포인터도 변수다 | : 포인터에 들어간 주소값이 바뀔 수 있다.

ex) a의 주소값이 들어갔다가 b의 주소값이 들어갈 수 있다.

https://modoocode.com/23