😎M.cloud☁️

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

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

| 함수의 원형 (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 형 변수에 인자(매개변수)로 받겠다."

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

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

사칙연산 : the four fundamental arithmetic operations

덧셈 : addition

뺄셈 : subtraction
곱셈 : multplication / multiply / times

나눗셈 : division

| 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

1. stack smashing : buffer overflow

root@DESKTOP-RMVJKG9:~/modoocode/13.Function# gcc 13.2_6_Use_function.c
13.2_6_Use_function.c:2:5: warning: conflicting types for built-in function ‘isdigit’; expected ‘int(int)’ [-Wbuiltin-declaration-mismatch]
    2 | int isdigit(char c);
      |     ^~~~~~~
13.2_6_Use_function.c:2:1: note: ‘isdigit’ is declared in header ‘<ctype.h>’
    1 | #include <stdio.h>
  +++ |+#include <ctype.h>
    2 | int isdigit(char c);

가능성 1. std 함수와 이름이 중복?

http://egloos.zum.com/rucaus/v/2352477

가능성 2. 함수 선언의 문제..(함수의 원형을 쓰지 않았거나 선언이 여러군데 일때..?)

https://blog.naver.com/PostView.nhn?isHttpsRedirect=true&blogId=plute&logNo=20193419934 

추측.. 타입의 문제인것 같은데..

#include <stdio.h>

int magicbox(i) {
    i += 4;
    return i;
}

int main() {
    int i;
    printf("a number to put in : \n");
    scanf("%d", &i);
    magicbox(i);
    return 0;
}

오류 문구 type of 'i' defaults to 'int'

문제 : 함수 정의 시 인자의 형태를 선언해 주지 않음.

해결 : 함수 선언 시 괄호 안에 인자의 형 선언해주면 해결.

magicbox( i ) => magicbox( int i )