New 병아리 개발자

*C언어 포인터(심화)

// 문제 : 원본값을 훼손하는 change 함수를 만들어주세요.
// 조건 : 매개변수 사용 없이 구현.
#include <stdio.h>

void change() {
  int num;
  printf("== change 함수 시작 ==\n");
  printf("&num : %ld\n", (long)&num);
  int* p = &num;
  *(p + 11) = 50;
  printf("== change 함수 끝 ==\n");
}

int main(void) {
  int x = 20;

  printf("&x : %ld\n", (long)&x);
  printf("change 함수 호출하기 전의 x : %d\n", x);

  change();  

  printf("change 함수 호출한 후의 x : %d\n", x);
  // 출력 => change 함수 호출한 후의 x : 50

  return 0;
}

*C언어 다중 포인터

#include <stdio.h>

int main() {
  int a = 20;

  printf("== 싱글포인터 ==\n");
  int* p;
  p = &a;
  printf("*p : %d\n", *p);
  printf("a : %d\n", a);


  printf("== 2중포인터 ==\n");
  int** pp;
  pp = &p;
  printf("*pp : %ld\n", (long)*pp);
  printf("p : %ld\n", (long)p);

  printf("**pp : %d\n", **pp);
  printf("a : %d\n", a);


  printf("== 3중포인터 ==\n");
  int*** ppp;
  ppp = &pp;
  printf("*ppp : %ld\n", (long)*ppp);
  printf("pp : %ld\n", (long)pp);

  printf("**ppp : %ld\n", (long)**ppp);
  printf("p : %ld\n", (long)p);
  
  printf("***ppp : %d\n", ***ppp);
  printf("a : %d\n", a);

  return 0;
}

*C언어 포인터

// 문제 : 포인터 변수 p를 이용해서 변수 2개의 값을 변경해주세요.
// 조건 : 변수 a, b에 값을 직접 할당하지 마세요.
#include <stdio.h>

int main(void) {
  int a = 10;
  int b = 20;

  int* p;
  
  p = &a;
  *p = 100;

  p = &b;
  *p = 200;

  printf("a : %d\n", a);
  // 출력 => a : 100
  printf("b : %d\n", b);
  // 출력 => b : 200

  return 0;
}



// 문제 : C언어에 있는 모든 기본포인터타입변수의 크기를 출력해주세요.
#include <stdio.h>

int main(void) {
  // 정수 계열
  char* c;
  short* s;
  int* i;
  long* l;
  
  // 실수 계열
  float* f;
  double* d;

  printf("== 정답 ==\n");

  printf("size of c : %lu\n", sizeof(c));
  printf("size of char* : %lu\n", sizeof(char*));

  printf("size of s : %lu\n", sizeof(s));
  printf("size of short* : %lu\n", sizeof(short*));

  printf("size of i : %lu\n", sizeof(i));
  printf("size of int* : %lu\n", sizeof(int*));

  printf("size of l : %lu\n", sizeof(l));
  printf("size of long* : %lu\n", sizeof(long*));

  printf("size of f : %lu\n", sizeof(f));
  printf("size of float* : %lu\n", sizeof(float*));

  printf("size of d : %lu\n", sizeof(d));
  printf("size of double* : %lu\n", sizeof(double*));
  
  return 0;
}



// 문제 : char 변수 b를 이용하지 않고 b의 값을 훼손
// 조건 : 포인터 변수를 사용해서 값을 변경해야 한다.
// 조건 : 수정가능 지역에서 b 라는 변수를 언급하면(사용하면) 안됩니다.
#include <stdio.h>

int main(void) {
  char a = 1;
  char b = 5;

  printf("== 변수의 주소 ==\n");
  printf("&a : %ld\n", (long)&a);
  printf("&b : %ld\n", (long)&b);

  char* p;
  
  p = &a;
  *p = 2;
  p = &a - 1;
  *p = 100;

  printf("== 변수의 값 ==\n");
  printf("a : %d\n", a);
  // 출력 => a : 2
  printf("b : %d\n", b);
  // 출력 => b : 10
  
  return 0;
}



// 문제 : int 변수 b를 이용하지 않고 b의 값을 훼손
// 조건 : 포인터 변수를 사용해서 값을 변경해야 한다.
// 조건 : 수정가능 지역에서 b 라는 변수를 언급하면(사용하면) 안됩니다.
#include <stdio.h>

int main(void) {
  int a = 1;
  int b = 5;

  printf("== 변수의 주소 ==\n");
  printf("&a : %ld\n", (long)&a);
  printf("&b : %ld\n", (long)&b);

  int* p;
  
  p = &a;
  *p = 2;
  p = &a - 1;
  *p = 10;

  printf("== 변수의 값 ==\n");
  printf("a : %d\n", a);
  // 출력 => a : 2
  printf("b : %d\n", b);
  // 출력 => b : 10
  
  return 0;
}



// 문제 : 변수의 주소를 올바른 포인터 변수에 저장하지 않은 예 구현
#include "stdio.h"

// int 변수를 가리키려면 int 전용 포인터 변수를 써야하는 이유

int main(void) {
  int i = 1000;
  char* cp = &i; // cp 에는 i 의 주소값이 저장된다.
  
  printf("%d\n", i);
  printf("%d\n", *cp); // 1000 이 아는 -24가 출력된다.
  // 오류가 나는 이유 : 물론 cp 는 i의 주소값을 가지고 있다. 하지만 cp는 i변수에 접근하고 나서 4바이트를 가져오지 않고 1 바이트만 가져온다.
  // 누군가를 가리키려면 주소값으로는 부족하다. 올바른 사이즈도 필요하다.
  
  return 0;
}



// 문제 : 원본값을 훼손하는 change 함수를 만들어주세요.
#include <stdio.h>

void change(int* num) {
  *num = 50;
}

int main(void) {
  int x = 20;

  printf("change 함수 호출하기 전의 x : %d\n", x);

  int* p;
  p = &x;
  change(p);

  printf("change 함수 호출한 후의 x : %d\n", x);
  // 출력 => change 함수 호출한 후의 x : 50

  return 0;
}

*C언어 변수타입

// 문제 : 변수를 만들고 3.14를 넣은 후 출력해보세요.(가장 메모리를 효율적으로 사용해주세요.)
#include "stdio.h"
   
int main(void) {
  int i = 3.14;
  
  printf("1st 시도 => i : %d\n", i); // 실패 => i 에는 오직 정수만 들어간다.
  
  float f = 3.14;
  
  printf("2nd 시도 => f : %d\n", f); // 실패 => `%d`는 데이터를 `int 로 해석하겠다.`라는 뜻 입니다.

  printf("3nd 시도 => f : %f\n", f);
  
  return 0;
}



// 문제 : 변수를 만들고 200을 넣은 후 출력해보세요.(가장 메모리를 효율적으로 사용해주세요.)
#include "stdio.h"

int main(void) {
  unsigned char i = 200;
  
  printf("i : %d\n", i);
  return 0;
}



// 문제 : 변수를 만들고 21억을 넣은 후 출력해보세요.(가장 메모리를 효율적으로 사용해주세요.)
#include "stdio.h"

int main(void) {
  int s = 2100000000;

  printf("s : %d\n", s);
  return 0;
}



// 문제 : 변수를 만들고 22억을 넣은 후 출력해보세요.(가장 메모리를 효율적으로 사용해주세요.)
#include "stdio.h"

int main(void) {
  int s = 2200000000;

  printf("1st 시도 => s : %d\n", s); // 실패, %d는 int로 취급된다. int는약 -21억부터 +21억까지 표현가능 하다.

  unsigned int k = 2200000000;

  printf("2st 시도 => k : %u\n", k);

  int q = 2200000000;

  printf("3st 시도 => q : %ld\n", q);
  
  return 0;
}



// 문제 : 변수를 만들고 400억을 넣은 후 출력해보세요.(가장 메모리를 효율적으로 사용해주세요.)
#include "stdio.h"

int main(void) {
  long s = 40000000000;
  
  printf("s : %ld", s);
  
  return 0;
}

*C언어 변수 크기 확인 ( sizeof(변수명) )

* 변수 크기 확인 (sizeof)
// 문제 : char와 unsigned char의 공간크기를 각각 출력해주세요.
// 힌트 : sizeof(변수) or sizeof(타입)
// 힌트 : sizeof 함수는 해당 매개변수의 공간크기를 반환합니다.
#include <stdio.h>

int main(void) {
  printf("char의 크기 : %lu\n", sizeof(char));
  printf("unsigned char의 크기 : %lu\n", sizeof(unsigned char));

  char c;
  unsigned char uc;

  printf("c의 크기 : %lu\n", sizeof(c));
  printf("uc의 크기 : %lu\n", sizeof(uc));

  return 0;
}

*모든 변수 타입의 크기 (바이트)

- 1 byte = 8 bit

// 문제 : C언어에 있는 모든 기본타입변수의 크기를 출력해주세요.

#include <stdio.h>

int main(void) {
    // 정수 계열
  char c; // 1바이트(돌 8개)
  short s; // 2바이트(돌 16개)
  int i; // 4바이트(돌 32개)
  long l; // 8바이트(돌 64개)
  
  // 실수 계열
  float f; // 4바이트(돌 32개)
  double d; // 8바이트(돌 64개)

  printf("char c변수의 크기 : %lu 바이트\n", sizeof(c));
  printf("short s변수의 크기 : %lu 바이트\n", sizeof(s));
  printf("int i 변수의 크기 : %lu 바이트\n", sizeof(i));
  printf("long l 변수의 크기 : %lu 바이트\n", sizeof(l));
  printf("float f 변수의 크기 : %lu 바이트\n", sizeof(f));
  printf("double d 변수의 크기 : %lu 바이트\n", sizeof(d));
  
  return 0;
}

*C언어 포인터

// 문제 : 변수 i의 값을 해킹해주세요.
// 조건 : i의 값을 직접 바꾸는 것은 안됩니다.
// 조건 : `i = 50;` 은 안됩니다.
#include <stdio.h>

int main(void) {
  int i = 30;

  // p는 i의 실제주소값을 가리킨다.
  int* p = &i;

  // p안에 들어있는 값을 메모리 상의 좌표값으로 인식하고 그 주소대로 찾아간다.(그러면 변수 i가 나온다.)
  *p = 50; // `i = 50;` 과 완벽히 같은 의미이다.

  printf("i : %d\n", i);
  // 출력 => i : 50

  return 0;
}



// 문제 : 변수 c의 값을 해킹해주세요.
// 조건 : c의 값을 직접 바꾸는 것은 안됩니다.
// 조건 : `c = 220;` 은 안됩니다.
#include <stdio.h>

int main(void) {
  unsigned char c = 200;

  unsigned char* p = &c;
  *p = 220;

  printf("c : %d\n", c);
  // 출력 => c : 220

  return 0;
}

*컴퓨터 구성

1. CPU : 연산

- 데이터 처리 속도 : 엄청빠름

- Read/Write 속도 : 엄청빠름

2. L1 Cache 메모리 : 저장

- 저장용량 : 작음 / 보통 8~64KB

- Read/Write 속도 : 엄청빠름(L2보다 빠름)

3. L2 Cache 메모리 : 저장

- 저장용량 : 작음 / 보통 64KB ~ 4MB

- Read/Write 속도 : 엄청빠름

4. 메모리 : 저장

- 저장용량 : 작음 / 8G

- Read/Write 속도 : 빠름

5. 하드디스크 : 저장

- 저장용량 : 큼

- Read/Write 속도 : 느림

*PC를 관리하는 소프트웨어 : 운영체제

- OS가 메모리를 관리한다.

- 우리가 만든 C 프로그램은 운영체제의 관리하에 실행된다.

- 즉 우리가 만든 프로그램은 운영체제에 메모리를 구걸한다.

- 우리가 만든 변수는 메모리에 할당된다.

- 즉 우리가 변수에 숫자 10을 넣으면, 그것은 메모리 어딘가에 저장된다.

*메모리 구역

- 메모리는 크게 2개의 구역으로 나뉜다.

- 힙 : 객체들의 세계, 위에서 내려온다.

- 스택 : 지역변수들의 세계, 아래에서 올라간다.

*C언어 포인터

- int i = 5; int* p = &i; *p = 10;

- 위 코드는 int i = 5; i = 10; 과 같은 의미 이다.

- int* p : int 변수의 주소를 저장 할 수 있는 변수 p를 만든다.

- &i : 변수 i의 리얼 주소를 알라낸다.

- *p : p에 들어있는 주소로 간다.

- *p = 10; : p에 들어있는 주소로 가면 4평짜리 땅(4바이트 공간)이 나오는데, 거기에 5가 들어있다. 그것을 10으로 바꾼다.