🐢 chap1. 필수 요소

⭐ 메모리

• C언어에서 메모리는 완전히 수동으로 관리

  • 메모리 영역을 할당하거나, 해제하기

🤎 프로세스 메모리 레이아웃

• 실행파일을 열 때마다 운영체제는 새 프로세스 만듦

  • 프로세스 : 실행중인 프로그램 (메모리에 로딩)

  • 고유의 프로세스 식별자 (PID) 가짐

    SIGTERM : 종료 신호 (프로세스 청소)

    SIGINT : 인터럽트 신호 (Ctrl + C 눌러 포그라운드 전방 프로세스로 전달)

    SIGKILL : 킬 신호 (프로세스 청소하지 않고 강제 종료)

• 프로세스를 생성할 때 운영체제는 프로세스를 위한 메모리를 가장 먼저 할당한 다음, 미리 정의된 메모리 레이아웃을 정의

  • 프로세스의 메모리 레이아웃은 여러 부분 (세그먼트)으로 분할됨
    • 초기화되지 않은 데이터 세그먼트 (BSS)
    • 데이터 세그먼트
    • 텍스트 세그먼트
    • 스택 세그먼트
    • 힙 세그먼트
  • 정적 메모리 레이아웃
    • 실행 중인 프로세스의 메모리 레이아웃에서 몇몇 세그먼트는 토대가 되는 실행 가능한 목적 파일에서 직접 만듦
    • 소스 코드를 컴파일 할 때 컴파일러가 실행 가능한 목적 파일에 미리 작성
  • 동적 메모리 레이아웃
    • 프로세스가 로딩될 때 프로그램이 실행되는 동안 동적으로 생성
    • 프로그램의 명령어에 따라 작성
      • 변수와 배열에 메모리가 할당, 프로그램의 로직에 따라 변수와 배열 수정

🤎 스택과 힙

• 스택
  • 함수 호출
  • 소유자 프로세스만이 읽고 수정할 권한을 갖는 전용 메모리
    • 디버거 : 디버그 하려는 다른 프로세스에 붙여서 사용하는 프로그램
      • 전용 메모리 블록 읽고 수정 가능
      • 프로그램 명령어 실행 순서 제어 가능
  • 스택의 가장 위에 할당된 버퍼에 확인되지 않은 값을 작성하는 일은 취약점을 ㅗ간주
    • 버퍼 오버플로 → 익스플로잇
  • 각 스택 변수는 고유의 스코프 갖고, 스코프는 변수의 수명 결정
    • 스택 변수 선언할 때마다 스택 세그먼트의 가장 윗부분에 할당

💡 **스택 세그먼트**
✅ 스택 메모리는 크기가 제한적 (큰 객체 저장하는데 좋은 장소 X)
✅ 스택 세그먼트의 주소는 작아짐
✅ 자동으로 메모리 관리 (할당 및 해제 모두 해당)
✅ 모든 스택 변수는 스코프를 가지며 스코프는 변수의 수명을 결정
✅ 포인터는 계속 스코프 내에 존재하는 스택 변수만을 가리켜야 함
✅ 스택 변수의 메모리 해제는 자동으로 수행됨
✅ 현재 스코프에 존재하는 변수에 대한 포인터는 다른 함수에 인자로 전달될 수 있음

• 힙
  • 자동으로 할당되는 메모리 블록을 갖지 않음
    • malloc, calloc, realloc 같은 함수로 힙 메모리 블록 얻기
      • malloc : 메모리 할당
      • calloc : 청소 및 할당
      • realloc : 이전의 블록에 있는 데이터 변경하지 않으며 이미 할당된 블록을 새로운 블록으로 확장함
      • free : 메모리 블록을 해제함
      • valgrind : 실행 중인 프로세스에서 메모리 문제를 감시할 수 이쓴 유용한 프로그램
  • 힙은 메모리 크기가 크다
    • 큰 객체 저장할 수 있음
  • 힙 메모리 내 에서 메모리의 할당과 해제는 개발자가 관리함
    • 개발자가 메모리를 할당하고, 해제하는 일은 유일한 개체라는 의미
    • 힙 블록을 비우는 일은 가비지 컬렉터가 수행하지만 C 기반에서는 없음
    • 실패하면 메모리 누수 발생
  • 힙에 할당된 변수는 스코프를 전혀 갖지 않음
  • 힙 메모리 블록의 주소를 지정하려면 포인터만 사용할 수 있음
  • 힙 세그먼트는 소유자 프로세스의 전용이므로 검사하려면 디버거를 사용해야함

💡 **힙 메모리**
✅ 힙 메모리 할당에 치러야 할 나름의 비용이 있음
✅ 힙 공간에 할당된 모든 메모리 블록은 더 이상 필요하지 않을 때나 프로그램 종료 직전에 해제되어야 함
✅ 힙 메모리 블록은 스코프를 갖지 않으므로, 반드시 메모리 관리할 수 있어야 함
✅ 각각의 힙 메모리 블록에 대한 메모리 관리 전략을 고수해야 함
✅ 선택한 전략과 전략에 관한 가정은 블록에 접근할 때마다 코드에 기록되어야 함
✅ RAII 객체를 사용해 힙 메모리 블록과 같은 리소스 관리 가능

⭐ 객체지향

💙 OOP와 캡슐화

• 개념 : 현실 세계의 개체에 관한 인식으로 형성
• OOP
  • 프로그램이 실행될 때 완전히 동적인 객체 모델로 이어질 일련의 명령어 만든다
  • OOD (객제지향 설계)
• 객체
  • 두 개 이상의 속성 또는 속성의 집합을 가질 수 있음
• 상태
  • 속성에 할당된 값을 총괄해 객체의 상태
  • 단순히 객체에 연결된 특정 속성에 속하는 값의 목록으로 이해됨

💙 도메인

• 소프트웨어 기능을 공개할 경계를 정의함
• 미리 정의된 구체적인 용어집을 사용해 임무를 수행함

💙 객체의 생성 계획 방법

• 빈 객체를 생성하거나 일반적으로 최소한의 속성의 집합을 갖는 객체를 생성하는 것
• 코드가 실행되는 동안 더 많은 속성이 결정되고 추가됨
• 각각의 객체는 별도의 개체로 취급됨
• 속성이 미리 정해져 있어서 실행 도중에 변경되지 않는 객체를 생성하는 것
  • 런타임 동안 어떠한 속성도 추가되지 못해 객체는 구조를 유지함
  • 속성값만 변경할 수 있으며, 객첵 가변적일 때만 가능
  • 모든 속성을 추적하는 미리 설계된 객체 템플릿 또는 클래스 생성해야 함
• 많은 프로그래밍 언어에서 이러한 객체 템플릿을 클래스라 함
• 참조
  • 객체의 값이 메모리에 할당된 실제 위치를 참조하는데 사용함
  • 객체와 인스턴스는 같은 것

💙 캡슐화

• 객체를 나타내는 캡슐에 서로 연관된 것을 집어넣는다
• 객체에서 어떤 속성이나 기능이 필요하다고 느낀 순간 마음속에서 캡슐화 하는 것
• 객체는 속성의 집합, 기능의 집합으로 만들어짐
• 속성과 기능 둘다 객체 캡슐로 캡슐화 되어야 함
• 속성 캡슐화
  • 명시적 캡슐화를 제공함
  • 개발자와 프로그래밍 언어 둘다 캡슐화, 캡슐의 존재를 안다는 것
• 행위 캡슐화
  • 메서드는 객체 내에 저장되는 로직, 기능, 행위을 나타냄
  • 속성은 값을 전달함
  • 암묵적 캡슐화는 명시적인 행위 캡슐화를 제공하지 않음
  • 행위 함수는 인자 중 하나로 반드시 구조체 포인터를 받아야 함
    • 객체의 동일한 클래스에 서로 연관되어있음을 나타내려면 적절한 이름이 있어야 함

💙 정보 은닉

• 외부 세계에 보이지 않아야 하는 어떠한 속성이나 행위를 보호하는 역할
  • 외부 세계 : 객체의 행위에 속하지 않는 모든 코드
• 비공개 행위 함수는 __접두어 붙인다

⭐ 1.1 전처리기 지시자

전처리 : preprocssing

수행: 일련의 지시자를 사용해 통제하고 영향을 줌

C 지시자: 헤더와 소스 파일에서 #으로 시작하는 코드(매크로, 조건부 컴파일)

1.1.1 매크로

💙 매크로의 활용

• 상수 정의하기
• C 함수를 작성하지 않고 함수로 사용하기
• 루프 풀기
• 헤더 가드
• 코드 생성
• 조건부 컴파일

💙 매크로 정의하기

#define 지시자를 이용해 정의: 각 매크로는 이름과 파라미터, 값을 가짐

#undef 지시자로 정의를 제거

• 예제 1-1

  #define ABC 5
  
  int main(int argc, char** argv) {
  	int x = 2;
  	int y = ABC;
  	int z = x + y;
  	return 0;
  }
  

  ABC는 변수가 아닌 매크로, 아래는 매크로 확장 후 코드

  int main(int argc, char** argv) {
  	int x = 2;
  	int y = 5;
  	int z = x + y;
  	return 0;
  }
  

• 예제 1-2

  #define ADD(a, b) a + b
  
  int main(int argc, char** argv) {
    int x = 2;
    int y = 3;
    int z = ADD(x, y);
    return 0;
  }
  

  ADD는 함수가 아닌 유사 함수 매크로, 아래는 전처리 후 코드

  int main(int argc, char** argv) {
    int x = 2;
    int y = 3;
    int z = x + y;
    return 0;
  }
  

매크로는 컴파일 단계 이전에만 존재, 이론적으로는 컴파일러가 매크로에 관해 모른다는 뜻

but ,현대의 C 컴파일러는 전처리 단계를 알고 있음

💙 가변 인자 매크로

• 예제 1-5

  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  
  #define VERSION "2.3.4"
  
  #define LOG_ERROR(format, ...) \
    fprintf(stderr, format, __VA_ARGS__)
  
  int main(int argc, char** argv) {
  
    if (argc < 3) {
      LOG_ERROR("Invalid number of arguments for version %s\n.",
              VERSION);
      exit(1);
    }
  
    if (strcmp(argv[1], "-n") != 0) {
      LOG_ERROR("%s is a wrong param at index %d for version %s.",
              argv[1], 1, VERSION);
      exit(1);
    }
  
    // ...
  
    return 0;
  }
  

  VA_ARGS 식별자: 아직 매개변수로 할당되지 않은 나머지 입력 인수로 모두 교체 fprintf 함수는 파일 서술자 stderr를 작성, 아래는 최종 출력 코드

  int main(int argc, char** argv) {
      if (argc < 3) {
          fprintf(stderr, "Invalid number of arguments for version %s\n.", "2.3.4");
          exit(1);
      }
      if (strcmp(argv[1], "-n") != 0) {
          fprintf(stderr, "%s is a wrong param at index %d for version %s.", argv[1],
              1, "2.3.4");
          exit(1);
      }
      // ...
      return 0;
  }
  

• 예제 1-6

  #include <stdio.h>
  
  #define LOOP_3(X, ...) \
    printf("%s\n", #X);
  
  #define LOOP_2(X, ...) \
    printf("%s\n", #X); \
    LOOP_3(__VA_ARGS__)
  
  #define LOOP_1(X, ...) \
    printf("%s\n", #X); \
    LOOP_2(__VA_ARGS__)
  
  #define LOOP(...) \
    LOOP_1(__VA_ARGS__)
  
  int main(int argc, char** argv) {
  
    LOOP(copy paste cut)
    LOOP(copy, paste, cut)
    LOOP(copy, paste, cut, select)
  
    return 0;
  }
  

  C++ Boost 프레임워크의 foreach 참고하기, 아래는 최종 코드

  int main(int argc, char** argv) {
  
    printf("%s\n", "copy paste cut"); printf("%s\n", "");
    printf("%s\n", "");
    printf("%s\n", "copy"); printf("%s\n", "paste"); printf("%s\n", "cut");
    printf("%s\n", "copy"); printf("%s\n", "paste"); printf("%s\n", "cut");
  
    return 0;
  }
  

  루프 풀기: 명령어를 루프에 넣지 않고 하나하나 두는 것 위 매크로는 리스트 요소를 세 개까지만 처리

💙 매크로의 장점과 단점

매크로는 컴파일 후 한 줄의 긴 코드로 교체되어 모듈성x

C 함수로 사용할 수 있다면 매크로 대신 C 함수로 작성

소프트웨어 설계와 디버깅 문제

루프 풀기와 성능 최적화

DSL 정의

1.1.2 조건부 컴파일

조건부 컴파일 지시자 목록

• #ifdef
• #ifndef
• #else
• #elif
• #endif

⭐ 1.2 포인터 변수

1.2.1 문법

포인터: 메모리 주소를 저장하는 단순한 변수

• 예제 1-9

  int main(int argc, char** argv) {
    int var = 100;
    int* ptr = 0;
    ptr = &var;
    *ptr = 200;
    return 0;
  }
  

  널 포인터 선언, 참조 연산자&, 역참조 연산자* NULL 매크로 사용: 변수와 포인터를 더 쉽게 구분

1.2.2 포인터 변수의 산술연산

산술연산 간격: 포인터가 1씩 증감할 때 움직이는 바이트의 숫자, C 자료형에 의해 결정됨

• 예제 1-10

  #include <stdio.h>
  
  int main(int argc, char** argv) {
    int var = 1;
  
    int* int_ptr = NULL; // 포인터를 널로 만들기
    int_ptr = &var;
  
    char* char_ptr = NULL;
    char_ptr = (char*)&var;
  
    printf("Before arithmetic: int_ptr: %u, char_ptr: %u\n",
            (unsigned int)int_ptr, (unsigned int)char_ptr);
  
    int_ptr++;    // 일반적으로 산술연산 간격은 4바이트
    char_ptr++;   // 1바이트의 산술연산 간격
  
    printf("After arithmetic: int_ptr: %u, char_ptr: %u\n",
            (unsigned int)int_ptr, (unsigned int)char_ptr);
  
    return 0;
  }
  

  실행 결과 정수 포인터의 연산 간격은 4바이트, 문자열 포인터는 1바이트

1.2.3 제네릭 포인터

제네릭 포인터: void* 자료형의 포인터, 역참조 불가능

• 예제 1-13

  #include <stdio.h>
  
  int main(int argc, char** argv) {
   int var = 9;
   int* ptr = &var;
   void* gptr = ptr;
  
   printf("%d\n", *gptr);
  
   return 0;
  }
  

  제네릭 포인터를 역참조하면 컴파일 오류가 생성됨

1.2.4 포인터의 크기

아키텍처에 따라 포인터의 크기가 다름

대상 아키텍처에서 sizeof 함수 사용

1.2.5 허상 포인터

충돌 또는 세그멘테이션 오류 발생

• 예제 1-15

  #include <stdio.h>
  
  int* create_an_integer(int default_value) {
    int var = default_value;
    return &var;
  }
  
  int main() {
    int* ptr = NULL;
    ptr = create_an_integer(10);
    printf("%d\n", *ptr);
    return 0;
  }
  

  세그멘테이션 오류 상황, ptr 포인터가 할당이 해제된 var의 메모리 영역을 가리킴(허상 포인터)

⭐ 1.3 함수

☑️ 함수의 구조

함수: 이름과 입력 매개변수의 목록, 출력 결과의 목록을 가진 논리 상자

C 언어에서 함수는 단 하나의 값만을 반환

블로킹 함수: 호출된 함수가 종료되어야만 반환값을 호출자 함수가 받을 수 있음

논블로킹 함수: 콜백 메커니즘, 비동기 함수, 사건 기반 프로그래밍(EDP)

☑️ 설계의 중요성

로직을 작성 후 다양한 곳에서 여러 번 사용 가능

추상화: 기존의 다른 로직으로부터 일부를 숨김

☑️ 스택 관리

스택 세그먼트 → 모든 지역 변수, 배열, 구조체가 할당되는 기본 메모리의 위치.

스택 프레임 → 스택 세그먼트의 가장 위에 놓이고, 함수 로직이 실행됩니다. 호출이 끝나면 스택 프레임은 제거되며 직전 호출 함수로 계속 이어집니다.

• 스택 프레임 예시

  int main()
  {
  	func1();
  }
  
  void func1()
  {
  	func2();
  }
  
  void func2()
  {
  
  }
  

스택 오버플로 → 스택에서는 메모리가 한정적입니다. 하지만 함수 호출을 너무 많이 실행해 스텍 프레임의 모든 스택 세그먼트를 다 써버린 경우에 발생합니다.

☑️ 값에 의한 전달 vs 참조에 의한 전달

C에는 참조가 없어, 참조에 의한 전달은 존재하지 않습니다.

오로지 값에 의한 전달만 존재합니다.

• 값에 의한 전달 함수 호출의 예

  #include <stdio.h>
  
  void swap(int, int);
  
  int main(void)
  {
  	int a = 5, b = 3;
  	printf("before) a = %d, b = %d\n", a, b);
  	swap(a, b);
  	printf("after) a= %d , b = %d\n", a, b);
  	return 0;
  }
  
  void swap(int num1, int num2)
  {
  	int temp = num1;
  	num1 = num2;
  	num2 = temp;
  
  	printf("swap) a = %d , b = %d\n", num1, num2);
  }
  
  /******************************************************
  before) a = 5, b = 3
  swap) a = 3 , b = 5
  after) a= 5 , b = 3
  *******************************************************/
  

포인터를 변수로 전달하는 것이 포인터에 의한 전달입니다.

• 포인터에 의한 함수 호출의 예

  #include <stdio.h>
  
  void func(int* a)
  {
  	int b = 9;
  	*a = 5;     //포인터 역참조
  	a = &b;
  }
  
  int main(void)
  {
  	int x = 3;
  	int* xptr = &x;
  	printf("the value before the call = %d \n", x);
  	printf("pointer value before the call = %p\n", xptr);
  	func(xptr);
  	printf("the value after the call = %d \n", x);
  	printf("pointer value after the call=%p \n", xptr);
  	return 0;
  }
  
  /******************************************************
  the value before the call = 3
  pointer value before the call = 0000007032AFF624
  the value after the call = 5
  pointer value after the call=0000007032AFF624
  *******************************************************/
  

  위의 결과를 보면 포인터의 값은 함수 호출 이후에도 변하지 않습니다. 이는 포인터가 값에 의한 전달 인수로 전달되었음을 의미합니다. 포인터를 역참조하면 호출하는 쪽의 함수의 변수를 수정할 수 있도록 합니다.

⭐ 1.4 함수 포인터

☑️ 함수 포인터

→ 함수의 주소를 저장하며 함수를 간접적으로 호출할 수 있도록 구현합니다.

→ 이로인해 각각의 기능들을 파일별로 나뉘어 놓는 작업인 모듈화가 가능해 졌습니다.

함수 포인터 변수 선언 = int (*fptr) (int);
int - 해당 함수의 반환형
(*fptr) - 포인터 변수
(int) - 해당함수의 매개변수의 형태

• 다른 함수 여러 개를 호출하는 하나의 함수 포인터

  #include <stdio.h>
  
  int sum(int a, int b)     // 타입 별칭으로 해두는 편이 좋습니다.
  {
  	return a + b;
  }
  
  int subtract(int a, int b)
  {
  	return a - b;
  }
  
  int main()
  {
  
  	int(*func_ptr)(int, int);
  	func_ptr = NULL;          // 함수 포인터도 NULL로 초기화를 해주어야합니다.
  
  	func_ptr = &sum;
  	int result = func_ptr(5, 4);
  	printf("Sum = %d\n", result);
  
  	func_ptr = &subtract;
  	result = func_ptr(5, 4);
  	printf("subtract = %d\n", result);
  
  	return 0;
  }
  
  Sum = 9
  subtract = 1
  

• 여러개의 다른 함수를 호출하는 하나의 함수 포인터

  #include <stdio.h>
  
  typedef int bool_t;
  typedef bool_t(*less_than_func_t)(int, int);
  
  bool_t less_than(int a, int b)
  {
  	return a < b ? 1 : 0;
  }
  
  bool_t less_than_modular(int a, int b)
  {
  	return (a % 5) < (b % 5) ? 1 : 0;
  }
  
  int main(void)
  {
  	less_than_func_t func_ptr = NULL;
  
  	func_ptr = &less_than;
  	bool_t result = func_ptr(3, 7);
  	printf("%d\n", result);
  
  	func_ptr = &less_than_modular;
  	result = func_ptr(3, 7);
  	printf("%d\n", result);
  	return 0;
  }
  
  1
  0
  

⭐ 1.5 구조체

☑️ 왜 구조체인가?

→ 원시 자료형 (PDT) = 자료구조를 설계할 수 있고, 알고리즘을 작성 할 수 있습니다.

ex) int, double

→ 사용자 정의 자료형 (UDT) = 직접 정의한 자료형이 필요하고, 프로그래밍 언어의 자료형으로는 충분하지 않을 때 사용합니다. struct 키워드를 사용합니다.

ex) 구조체

(구조체는 하나 이상의 변수를 하나로 묶을 수 있는 복합 자료형이므로 기본 자료형 변수를 묶어서 새로운 자료형을 만든 것이기 때문에 사용자 정의 자료형으로 구분됩니다.)

→ 다양한 형태의 데이터를 처리할 때 유용합니다.

☑️ 왜 사용자 정의 자료형인가?

같은 대상에 서로 연관된 속성을 그룹으로 묶는것이 가독성이 좋습니다. 더 고수준의 로직, 인간 수준의 로직과 충분히 비슷하게 문제를 분석하려면 새로운 자료형이 필요합니다.

ex) 비즈니스 로직 -은행(고객, 잔고, 돈, 현금, 지불) 개념을 마주하고, 은행 로직을 개발하기 위해서는 개발자와 비즈니스 분석가는 협력하며 규칙, 로직, 용어집등을 공유해야합니다.

☑️ 구조체의 역할

구조체는 하나의 통합된 타입아래 관련된 값을 갭슐화 합니다.

ex) color_t (red, green,blue)

struct color_t {
	int red;
	int green;
	int blue;
};

→ 새로운 자료형 아래에 서로 관련이 있는 필드를 그룹으로 묶는 캡슐화 합니다. 그리고 나서 필요한 변수를 정의할 때 이 새로운 자료형을 사용합니다.

☑️ 메모리 레이아웃

메모리 레이아웃이 필요한 이유 → 값은 메모리에 저장되고, cpu는 이 값을 충분히 빠르게 읽고 쓸 수 있어야 합니다.

• 구조체 변수에 할당된 바이트 수 출력하기

  #include <stdio.h>
  
  struct sample_t {
      char first;
      char second;
      char third;
      short fourth;
  };
  
  void print_size(struct sample_t* var) {
      printf("Size: %lu bytes\n", sizeof(*var));
  }
  
  void print_bytes(struct sample_t* var) {
      unsigned char* ptr = (unsigned char*)var;
      for (int i = 0; i < sizeof(*var); i++, ptr++) {
          printf("%d ", (unsigned int)*ptr);
      }
      printf("\n");
  }
  
  int main(int argc, char** argv) {
      struct sample_t var;
      var.first = 'A';
      var.second = 'B';
      var.third = 'C';
      var.fourth = 765;
      print_size(&var);
      print_bytes(&var);
      return 0;
  }
  
  Size: 6 bytes
  65 66 67 0 253 2
  

  sizeof(sample_t)는 6바이트를 반환합니다.

  • char형 3개 short형 1개 총 5바이트 입니다. 이는 메모리 정렬을 위해 바이트 67뒤에 0이 보이게 합니다. 0바이트는 현재 워드(cpu가 메모리에 접근할 때 읽는 특정 바이트의 수)를 완성하기 위해 추가되며, 네 번째 필드가 다음 워드에서 시작할 수 있도록 합니다.

  • 이때 메모리 정렬이란 시작하는 바이트가 워드의 시작점에 있을 때, 이 변수는 메모리에 정렬 되었다고 합니다. ex) char형인 first, second, third는 각각 1바이트이며 이들은 구조체 레이아웃의 첫번째 워드에 탑재 됩니다. 이후 fouth 는 2바이트 입니다. 만일 메모리 정렬이 되지 않는다면 첫번째 바이트는 첫번째 워드의 마지막 바이트가 되게 됩니다.

    이를 방지하기 위해 첫번째 워드는 0바이트 하나가 패킹(메모리 값을 정렬)되어 있다고 할 수 있습니다.
    

  • 메모리 정렬은 기본적으로 활성화가 되어 있습니다.

☑️ 중첩 구조체

복합 자료형 = 사용자 정의 자료형이고, 몇 개의 구조체를 중첩한 결과입니다.

• 몇가지 중첩 구조체

  #include <stdio.h>
  
  typedef struct {
  	int x;			//4byte
  	int y;			//4byte
  }point_t;			//8byte
  
  typedef struct {
  	point_t center;	//8byte
  	int radius;		//4byte
  }circle_t;			//12byte
  
  typedef struct {
  	point_t start;	//8byte
  	point_t end;	//8byte
  }line_t;			//16byte
  

  3개의 구조체인 point_t와 circle_t, line_t가 존재합니다. point_t 구조체는 오직 원시자료형으로만 구성된 단순한 사용자 정의 자료형이지만 다른 구조체들은 point_t 자료형의 변수를 포함한 복합 사용자 정의 자료형입니다.

☑️ 구조체 포인터

→ 사용자 정의 자료형의 포인터는 원시 자료형의 포인터와 동일합니다.

→ 구조체 변수 포인터가 구조체 변수의 첫 번째 필드의 주소를 가르킵니다.

• 메모리에서 동일한 바이트 주소를 가리키는 세 가지 자료형으로부터 얻는 3개의 포인터

  #include <stdio.h>
  
  typedef struct {
  	int x;
  	int y;
  }point_t;
  
  typedef struct {
  	point_t center;
  	int raduus;
  }circle_t;
  
  int main(void)
  {
  	circle_t c;
  
  	circle_t* p1 = &c;
  	point_t* p2 = (point_t*)&c;
  	int* p3 = (int*)&c;
  
  	printf("p1 = %p\n", (void*)p1);
  	printf("p2 = %p\n", (void*)p2);
  	printf("p3 = %p\n", (void*)p3);
  	return 0;
  }
  
  p1 = 00000039EEB9F738
  p2 = 00000039EEB9F738
  p3 = 00000039EEB9F738
  

  point_t와 circle_t 자료형의 포인터는 구조체의 변수의 첫번째 필드인 x의 주소를 가리켰습니다. typedef를 사용하면 구조체의 새 별칭 타입을 선언 할 수 있습니다. 이는 추후에 struct 키워드를 사용하지 않고 변수를 사용할 수 있습니다.