MENU
  1. ホーム
  2. C 언어
  3. C 언어에서 헤더 파일 다중 포함 방지 기법

C 언어에서 헤더 파일 다중 포함 방지 기법

C 언어

C 언어에서 헤더 파일이 다중으로 포함되는 경우 컴파일 오류나 비효율적인 코드가 생성될 수 있습니다. 이러한 문제는 특히 복잡한 프로젝트에서 종종 발생하며, 디버깅 시간을 크게 증가시킬 수 있습니다. 본 기사에서는 헤더 파일 다중 포함 문제의 원인과 이를 방지하기 위한 다양한 기법을 설명합니다. 개발 과정에서 이러한 전략을 활용하면 코드의 안정성과 유지보수성을 높일 수 있습니다.

목차
  1. 헤더 파일 다중 포함이란?
    1. 다중 포함의 문제점
    2. 예시 코드
  2. 헤더 파일 다중 포함이 발생하는 상황
    1. 의존 관계에 의한 다중 포함
    2. 중복 선언과 중복 정의
    3. 매크로 확장에 의한 다중 포함
  3. #include 가드란?
    1. #include 가드의 기본 구조
    2. #include 가드의 일반적인 형식
    3. #include 가드의 동작 원리
    4. 고유한 매크로 이름의 중요성
  4. #include 가드 구현 예시
    1. 예제 코드
    2. 코드 설명
    3. 사용 예시
    4. 컴파일 결과
    5. 중요 포인트
  5. #pragma once의 역할과 장단점
    1. #pragma once의 기본 개념
    2. 예제 코드
    3. 장점
    4. 단점
    5. #pragma once와 #include 가드 비교
    6. 사용 권장 상황
  6. #include 가드와 #pragma once 선택 가이드
    1. 기준 1: 컴파일러 지원 여부
    2. 기준 2: 프로젝트 규모와 복잡성
    3. 기준 3: 코드 유지보수와 가독성
    4. 기준 4: 성능 요구사항
    5. 요약 가이드
    6. 권장 예시
  7. 다중 포함 방지 모범 사례
    1. 헤더 파일별로 고유한 매크로 사용
    2. 헤더 파일과 구현 파일의 역할 분리
    3. 의존성 최소화
    4. 헤더 파일 포함 순서 지키기
    5. 중복 포함 방지와 `#pragma once` 사용
    6. 모듈화 설계와 헤더 파일 분리
    7. 정기적인 코드 리뷰
    8. 요약
  8. 헤더 파일 구조 최적화
    1. 1. 의존성 최소화
    2. 2. 중복 헤더 포함 방지
    3. 3. 헤더 파일의 계층적 구조화
    4. 4. 헤더 파일의 역할 명확화
    5. 5. `#include` 순서 최적화
    6. 6. 헤더 파일의 주석과 문서화
    7. 최적화의 효과
  9. 요약

헤더 파일 다중 포함이란?


헤더 파일 다중 포함은 동일한 헤더 파일이 여러 번 포함되는 상황을 말합니다. 이는 일반적으로 헤더 파일이 다른 소스 파일이나 헤더 파일에서 반복적으로 #include될 때 발생합니다.

다중 포함의 문제점


다중 포함은 다음과 같은 문제를 초래할 수 있습니다.

  • 컴파일 오류: 동일한 함수, 변수, 매크로, 또는 구조체가 여러 번 정의되어 컴파일러가 중복 정의 오류를 발생시킵니다.
  • 컴파일 속도 저하: 헤더 파일이 여러 번 처리되어 컴파일 시간이 증가합니다.
  • 코드 유지보수의 어려움: 다중 포함 문제를 추적하고 해결하는 데 많은 시간이 소요됩니다.

예시 코드


다중 포함 문제를 유발할 수 있는 코드 예는 다음과 같습니다.

// file1.h
struct Example {
    int value;
};

// file2.h
#include "file1.h"

// main.c
#include "file1.h"
#include "file2.h"

위 코드에서 file1.h는 main.c에서 두 번 포함되어 구조체 Example의 중복 정의 오류를 발생시킵니다.

이러한 문제를 예방하려면 적절한 다중 포함 방지 전략이 필요합니다.

헤더 파일 다중 포함이 발생하는 상황

의존 관계에 의한 다중 포함


다중 포함은 소스 코드 파일과 헤더 파일 간의 의존 관계가 복잡할 때 자주 발생합니다. 한 헤더 파일이 다른 헤더 파일을 포함하고, 이를 다시 소스 코드 파일에서 포함할 경우 문제가 발생할 수 있습니다.

예시:

// file1.h
struct Data {
    int value;
};

// file2.h
#include "file1.h"
void processData(struct Data *data);

// main.c
#include "file1.h"
#include "file2.h"

file1.h는 main.c와 file2.h에 포함되며, 결과적으로 main.c에 두 번 포함됩니다.

중복 선언과 중복 정의


헤더 파일에 변수나 함수가 선언 또는 정의되어 있을 때 중복 문제가 발생합니다. 예를 들어, 전역 변수를 헤더 파일에서 정의하고 이를 여러 소스 파일에서 포함하면 중복 정의 오류가 발생할 수 있습니다.

예시:

// file1.h
int globalVariable = 0; // 정의

// file2.c
#include "file1.h"

// main.c
#include "file1.h" // 중복 정의 오류 발생

매크로 확장에 의한 다중 포함


매크로로 조건을 제어하지 않은 상태에서 동일한 헤더 파일이 여러 번 포함되면 불필요한 매크로 중복 확장이 발생할 수 있습니다.

예시:

// file1.h
#define VALUE 10

// main.c
#include "file1.h"
#include "file1.h" // VALUE가 두 번 정의되어 경고 또는 오류 발생

이러한 상황들은 모두 헤더 파일 다중 포함의 원인이 되며, 이를 방지하기 위한 구체적인 전략이 필요합니다.

#include 가드란?

#include 가드는 헤더 파일이 동일한 번역 단위 내에서 여러 번 포함되는 것을 방지하기 위한 전처리기 지시문입니다. 가드문을 사용하면 헤더 파일이 이미 포함되었는지 확인하고, 중복 포함을 방지합니다.

#include 가드의 기본 구조


#include 가드는 전처리 매크로를 활용하여 헤더 파일이 이미 정의되었는지 검사합니다. 이를 구현하기 위해 세 가지 주요 구성 요소를 사용합니다.

  1. 매크로 정의: 헤더 파일이 처음 포함될 때 고유한 이름의 매크로를 정의합니다.
  2. 조건 검사: 매크로가 이미 정의되었는지 확인합니다.
  3. 내용 포함: 매크로가 정의되지 않은 경우에만 헤더 파일 내용을 포함합니다.

#include 가드의 일반적인 형식


다음은 #include 가드의 일반적인 형태입니다.

#ifndef HEADER_FILE_NAME
#define HEADER_FILE_NAME

// 헤더 파일 내용
void exampleFunction();

#endif // HEADER_FILE_NAME

#include 가드의 동작 원리

  1. #ifndef HEADER_FILE_NAME는 해당 매크로가 정의되지 않았을 때만 코드를 실행합니다.
  2. #define HEADER_FILE_NAME는 매크로를 정의하여 이후 포함 시 조건이 참이 되지 않도록 합니다.
  3. #endif는 조건 검사의 끝을 표시합니다.

고유한 매크로 이름의 중요성


HEADER_FILE_NAME은 전역적으로 고유해야 합니다. 일반적으로 파일 이름과 프로젝트 이름을 결합하여 고유성을 확보합니다.
예:

#ifndef PROJECTNAME_FILE1_H
#define PROJECTNAME_FILE1_H

#include 가드는 간단하지만 효과적인 다중 포함 방지 방법으로, 모든 C 언어 프로젝트에서 표준적으로 사용됩니다.

#include 가드 구현 예시

아래는 실제 헤더 파일에서 #include 가드를 구현하는 예제입니다. 이 코드는 간단한 함수와 구조체를 정의한 헤더 파일에 #include 가드를 추가한 사례를 보여줍니다.

예제 코드

// example.h
#ifndef EXAMPLE_H
#define EXAMPLE_H

// 구조체 정의
typedef struct {
    int id;
    char name[50];
} ExampleStruct;

// 함수 선언
void printExample(const ExampleStruct *example);

#endif // EXAMPLE_H

코드 설명

  1. #ifndef EXAMPLE_H
  • EXAMPLE_H 매크로가 정의되지 않은 경우에만 코드 블록이 실행됩니다.
  1. #define EXAMPLE_H
  • 매크로를 정의하여 이후 이 헤더 파일이 다시 포함될 때 중복 포함을 방지합니다.
  1. 헤더 파일 내용
  • 구조체 ExampleStruct와 함수 printExample의 선언이 포함됩니다.
  1. #endif
  • #ifndef 블록을 닫습니다.

사용 예시


헤더 파일이 여러 소스 파일에서 포함되는 경우를 시뮬레이션한 코드입니다.

// main.c
#include "example.h"
#include "example.h" // 두 번째 포함되어도 문제가 발생하지 않음

#include <stdio.h>
void printExample(const ExampleStruct *example) {
    printf("ID: %d, Name: %s\n", example->id, example->name);
}

int main() {
    ExampleStruct ex = {1, "Test"};
    printExample(&ex);
    return 0;
}

컴파일 결과


이 코드는 #include 가드 덕분에 example.h가 두 번 포함되더라도 컴파일 오류 없이 정상적으로 실행됩니다.

중요 포인트

  • #include 가드에 사용할 매크로 이름은 파일 이름과 연관된 고유한 이름으로 작성해야 합니다.
  • 대규모 프로젝트에서 헤더 파일의 중복 포함을 방지하기 위해 모든 헤더 파일에 #include 가드를 추가하는 것이 권장됩니다.

#pragma once의 역할과 장단점

#pragma once는 #include 가드와 동일한 역할을 하는 전처리기 지시문입니다. 이 지시문은 헤더 파일이 동일한 번역 단위에서 한 번만 포함되도록 보장합니다.

#pragma once의 기본 개념


#pragma once를 사용하면 매크로 정의 없이 헤더 파일의 중복 포함을 방지할 수 있습니다. 이 지시문은 헤더 파일이 이미 포함되었는지 여부를 컴파일러가 자동으로 관리합니다.

예제 코드

// example.h
#pragma once

typedef struct {
    int id;
    char name[50];
} ExampleStruct;

void printExample(const ExampleStruct *example);

장점

  1. 코드 간결성
  • #pragma once는 매크로 정의와 조건문이 필요하지 않아 코드가 간단하고 가독성이 좋습니다.
  1. 오류 방지
  • 중복 매크로 이름으로 인한 충돌 위험이 없습니다.
  1. 컴파일 속도 향상
  • 대부분의 컴파일러에서 #pragma once는 파일 시스템 수준에서 검사하므로 처리 속도가 빠릅니다.
  1. 유지보수 용이
  • 매크로 이름 관리가 필요 없으므로 헤더 파일 유지보수가 쉬워집니다.

단점

  1. 표준화 부족
  • #pragma once는 C 표준의 일부가 아니며, 특정 컴파일러에서만 지원됩니다. 하지만 현재는 대부분의 현대 컴파일러(GCC, Clang, MSVC 등)가 이를 지원합니다.
  1. 파일 경로 의존성
  • 헤더 파일이 심볼릭 링크나 복사된 경로로 참조되는 경우, 컴파일러가 중복 파일로 인식할 가능성이 있습니다.

#pragma once와 #include 가드 비교

특징#include 가드#pragma once
지원 여부표준 지원비표준, 대부분의 컴파일러 지원
코드 길이매크로 정의 필요단일 지시문
충돌 가능성매크로 이름 중복 가능충돌 없음
컴파일 속도파일 내용 처리 필요파일 시스템 처리로 빠름

사용 권장 상황

  • #pragma once 사용 권장: 최신 컴파일러를 사용하는 경우 간결하고 효율적인 #pragma once를 사용하는 것이 적합합니다.
  • #include 가드 사용 권장: 레거시 코드나 비표준 컴파일러를 사용하는 환경에서는 호환성을 위해 #include 가드를 사용하는 것이 더 안전합니다.

#pragma once는 간결성과 효율성을 제공하지만, 표준화된 방법인 #include 가드와 병행하여 사용하는 전략도 고려할 수 있습니다.

#include 가드와 #pragma once 선택 가이드

헤더 파일 다중 포함을 방지하기 위해 #include 가드와 #pragma once 중 어떤 방법을 사용할지 결정하는 것은 프로젝트의 특성과 환경에 따라 달라집니다. 아래는 두 방법의 선택을 돕기 위한 가이드입니다.

기준 1: 컴파일러 지원 여부

  • 최신 컴파일러 환경
    대부분의 최신 컴파일러(GCC, Clang, MSVC)는 #pragma once를 완벽히 지원하므로 이를 사용하는 것이 적합합니다.
  • 레거시 컴파일러 환경
    표준을 준수하지 않는 오래된 컴파일러를 사용하는 경우 #include 가드가 더 안전합니다.

기준 2: 프로젝트 규모와 복잡성

  • 소규모 프로젝트
  • 소스 파일과 헤더 파일이 적은 경우 #pragma once를 사용하면 코드가 간결해지고 관리가 쉬워집니다.
  • 대규모 프로젝트
  • 다중 플랫폼 지원이나 복잡한 의존 관계가 있는 경우 #include 가드가 파일 경로 관련 문제를 피하는 데 유리합니다.

기준 3: 코드 유지보수와 가독성

  • 가독성이 중요한 경우
  • #pragma once는 간결한 문법 덕분에 헤더 파일을 빠르게 이해할 수 있습니다.
  • 명시적 제어가 필요한 경우
  • #include 가드는 명시적으로 매크로를 정의하므로 관리가 까다롭지만 세밀한 제어가 가능합니다.

기준 4: 성능 요구사항

  • 컴파일 속도 최적화
  • #pragma once는 파일 시스템 기반의 중복 검사로 인해 대부분의 컴파일러에서 빠르게 처리됩니다.

요약 가이드

상황추천 방법이유
최신 컴파일러와 단일 플랫폼 사용#pragma once간결한 문법과 성능 최적화
다중 플랫폼 또는 레거시 환경 지원 필요#include 가드모든 컴파일러에서 동작 보장
프로젝트 파일 경로가 복잡한 경우#include 가드경로 의존성을 줄이고 확실한 다중 포함 방지
가독성과 유지보수가 최우선인 경우#pragma once짧고 읽기 쉬운 문법 제공

권장 예시

  • 소규모 및 현대적 프로젝트
  // modern_example.h
  #pragma once

  void modernFunction();
  • 대규모 및 레거시 지원 프로젝트
  // legacy_example.h
  #ifndef LEGACY_EXAMPLE_H
  #define LEGACY_EXAMPLE_H

  void legacyFunction();

  #endif // LEGACY_EXAMPLE_H

#pragma once와 #include 가드는 각각의 장단점이 있으므로 프로젝트 환경과 요구사항에 맞춰 적절히 선택해야 합니다.

다중 포함 방지 모범 사례

헤더 파일의 다중 포함 문제를 예방하기 위해서는 올바른 설계와 관리가 필수적입니다. 다음은 실무에서 활용할 수 있는 다중 포함 방지 모범 사례입니다.

헤더 파일별로 고유한 매크로 사용

  • #include 가드를 사용할 경우, 헤더 파일마다 고유한 매크로 이름을 정의해야 합니다.
  • 파일 이름과 프로젝트 이름을 결합해 고유성을 보장합니다.

예:

#ifndef PROJECTNAME_FILENAME_H
#define PROJECTNAME_FILENAME_H

// 헤더 파일 내용

#endif // PROJECTNAME_FILENAME_H

헤더 파일과 구현 파일의 역할 분리

  • 함수와 변수의 선언은 헤더 파일에, 정의는 소스 파일(.c)에 배치합니다.
  • 헤더 파일에서 직접 정의를 포함하지 않으면 중복 정의 오류를 방지할 수 있습니다.

예:

// example.h
#ifndef EXAMPLE_H
#define EXAMPLE_H

void exampleFunction();

#endif // EXAMPLE_H

// example.c
#include "example.h"
void exampleFunction() {
    // 함수 정의
}

의존성 최소화

  • 헤더 파일에는 필요한 최소한의 선언만 포함합니다.
  • 불필요한 헤더 파일 포함을 줄이기 위해 전방 선언(forward declaration)을 적극 활용합니다.

예:

// forward declaration 활용
struct ExampleStruct; // 구조체에 대한 전방 선언

void processExample(struct ExampleStruct *example); // 함수 선언

헤더 파일 포함 순서 지키기


헤더 파일의 포함 순서는 명확하고 일관되게 유지해야 합니다. 일반적으로 다음 순서를 따릅니다.

  1. 관련 헤더 파일
  2. 표준 라이브러리 헤더
  3. 외부 라이브러리 헤더
  4. 프로젝트 내부 헤더

중복 포함 방지와 `#pragma once` 사용

  • 최신 프로젝트에서는 #pragma once를 기본적으로 사용하여 중복 포함 문제를 간단히 해결합니다.
  • 다중 플랫폼 프로젝트에서는 여전히 #include 가드를 병행하는 것이 안전합니다.

모듈화 설계와 헤더 파일 분리

  • 기능별로 헤더 파일을 분리하여 한 파일에 너무 많은 내용이 포함되지 않도록 합니다.
  • 각 헤더 파일은 독립적으로 동작할 수 있도록 설계합니다.

예:

// math_utils.h
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int add(int a, int b);
int subtract(int a, int b);

#endif // MATH_UTILS_H

// io_utils.h
#ifndef IO_UTILS_H
#define IO_UTILS_H

void printMessage(const char *message);

#endif // IO_UTILS_H

정기적인 코드 리뷰

  • 헤더 파일의 구조와 포함 관계를 정기적으로 점검하여 불필요한 포함 문제를 제거합니다.
  • 코딩 규칙을 문서화하고 팀원 간의 합의를 통해 이를 유지합니다.

요약

  • 고유 매크로 이름과 전방 선언을 활용해 다중 포함 문제를 방지합니다.
  • 헤더 파일 설계를 간결하게 유지하고, 필요 없는 의존성을 제거합니다.
  • #pragma once와 #include 가드를 상황에 맞게 선택하여 사용합니다.
    위의 모범 사례를 실천하면 프로젝트의 안정성과 유지보수성을 크게 향상시킬 수 있습니다.

헤더 파일 구조 최적화

효율적이고 유지보수하기 쉬운 코드를 작성하려면 헤더 파일의 구조를 최적화해야 합니다. 이는 중복 포함을 방지할 뿐만 아니라, 컴파일 속도를 개선하고 코드 가독성을 높이는 데 기여합니다.

1. 의존성 최소화

  • 헤더 파일에는 필요한 최소한의 선언만 포함합니다.
  • 구조체와 클래스 등 복잡한 선언이 필요하지 않다면 전방 선언(forward declaration)을 사용합니다.

예:

// forward declaration 사용
struct ExampleStruct; // 구조체 선언만 노출
void useExample(struct ExampleStruct *example); // 세부 정의는 소스 파일에서 처리

2. 중복 헤더 포함 방지

  • 중복 헤더 포함은 컴파일 시간 증가와 다중 포함 문제의 원인이 됩니다.
  • 필요 없는 헤더 파일 포함은 제거하고, 관련성이 높은 헤더만 포함합니다.

예:

// 필요 없는 #include 제거
#include <stdio.h>
#include <stdlib.h>
#include "math_utils.h" // 필요한 헤더만 포함

3. 헤더 파일의 계층적 구조화

  • 프로젝트의 복잡성이 증가함에 따라 헤더 파일은 모듈화되고 계층적으로 구성되어야 합니다.
  • 공통으로 사용되는 헤더는 별도의 디렉토리 또는 라이브러리로 분리합니다.

예:

project/
├── include/
│   ├── math/
│   │   ├── math_utils.h
│   │   └── algebra.h
│   ├── io/
│   │   ├── file_utils.h
│   │   └── console.h
│   └── common.h
└── src/
    ├── math/
    │   ├── math_utils.c
    │   └── algebra.c
    ├── io/
    │   ├── file_utils.c
    │   └── console.c
    └── main.c

4. 헤더 파일의 역할 명확화

  • 헤더 파일은 선언만 포함하고, 구현은 소스 파일에서 처리합니다.
  • 헤더 파일에 전역 변수나 함수 정의를 포함하지 않도록 주의합니다.

잘못된 예:

// 잘못된 예: 헤더 파일에서 정의
int globalVariable = 0; // 전역 변수 정의

올바른 예:

// example.h
#ifndef EXAMPLE_H
#define EXAMPLE_H

extern int globalVariable; // 전역 변수 선언

#endif // EXAMPLE_H

// example.c
#include "example.h"
int globalVariable = 0; // 전역 변수 정의

5. `#include` 순서 최적화

  • #include 순서를 표준화하여 컴파일 오류를 방지하고 의존 관계를 명확히 합니다.
  • 일반적으로 다음 순서를 따릅니다:
  1. 프로젝트 헤더
  2. 외부 라이브러리 헤더
  3. 표준 라이브러리 헤더

예:

#include "example.h"      // 프로젝트 헤더
#include "external_lib.h" // 외부 라이브러리
#include <stdio.h>        // 표준 라이브러리

6. 헤더 파일의 주석과 문서화

  • 헤더 파일의 상단에 파일의 역할과 포함 방법에 대한 주석을 추가합니다.
  • 중요한 함수나 구조체에는 간단한 설명을 포함하여 가독성을 높입니다.

예:

// example.h
// 이 파일은 ExampleStruct와 관련된 함수 선언을 포함합니다.

#ifndef EXAMPLE_H
#define EXAMPLE_H

// ExampleStruct 정의
typedef struct {
    int id;
    char name[50];
} ExampleStruct;

// ExampleStruct를 출력하는 함수
void printExample(const ExampleStruct *example);

#endif // EXAMPLE_H

최적화의 효과

  • 불필요한 컴파일 시간 감소
  • 다중 포함 문제 제거
  • 코드 가독성과 유지보수성 향상

헤더 파일의 구조를 최적화하면 대규모 프로젝트에서도 코드를 더 효율적으로 관리할 수 있습니다. 이는 생산성과 품질을 동시에 향상시키는 중요한 요소입니다.

요약

C 언어에서 헤더 파일 다중 포함 문제를 해결하기 위해 #include 가드와 #pragma once 같은 기법을 활용할 수 있습니다. 헤더 파일 설계를 최적화하면 컴파일 오류와 성능 저하를 방지할 수 있으며, 유지보수가 쉬운 코드를 작성할 수 있습니다.

#include 가드는 표준화된 방식으로 모든 컴파일러에서 안정적으로 작동하며, #pragma once는 더 간결하고 빠른 처리 속도를 제공합니다. 프로젝트 환경과 요구사항에 맞춰 적절한 방식을 선택하고, 모범 사례를 따른다면 안정적이고 효율적인 소프트웨어 개발이 가능해집니다.

C 언어
C언어 다중 포함 방지 헤더 파일
목차
  1. 헤더 파일 다중 포함이란?
    1. 다중 포함의 문제점
    2. 예시 코드
  2. 헤더 파일 다중 포함이 발생하는 상황
    1. 의존 관계에 의한 다중 포함
    2. 중복 선언과 중복 정의
    3. 매크로 확장에 의한 다중 포함
  3. #include 가드란?
    1. #include 가드의 기본 구조
    2. #include 가드의 일반적인 형식
    3. #include 가드의 동작 원리
    4. 고유한 매크로 이름의 중요성
  4. #include 가드 구현 예시
    1. 예제 코드
    2. 코드 설명
    3. 사용 예시
    4. 컴파일 결과
    5. 중요 포인트
  5. #pragma once의 역할과 장단점
    1. #pragma once의 기본 개념
    2. 예제 코드
    3. 장점
    4. 단점
    5. #pragma once와 #include 가드 비교
    6. 사용 권장 상황
  6. #include 가드와 #pragma once 선택 가이드
    1. 기준 1: 컴파일러 지원 여부
    2. 기준 2: 프로젝트 규모와 복잡성
    3. 기준 3: 코드 유지보수와 가독성
    4. 기준 4: 성능 요구사항
    5. 요약 가이드
    6. 권장 예시
  7. 다중 포함 방지 모범 사례
    1. 헤더 파일별로 고유한 매크로 사용
    2. 헤더 파일과 구현 파일의 역할 분리
    3. 의존성 최소화
    4. 헤더 파일 포함 순서 지키기
    5. 중복 포함 방지와 `#pragma once` 사용
    6. 모듈화 설계와 헤더 파일 분리
    7. 정기적인 코드 리뷰
    8. 요약
  8. 헤더 파일 구조 최적화
    1. 1. 의존성 최소화
    2. 2. 중복 헤더 포함 방지
    3. 3. 헤더 파일의 계층적 구조화
    4. 4. 헤더 파일의 역할 명확화
    5. 5. `#include` 순서 최적화
    6. 6. 헤더 파일의 주석과 문서화
    7. 최적화의 효과
  9. 요약