MENU
  1. ホーム
  2. C 언어
  3. C언어 전처리기를 활용한 안전한 조건부 코드 실행 방법

C언어 전처리기를 활용한 안전한 조건부 코드 실행 방법

C 언어

C언어에서 전처리기는 컴파일러가 소스 코드를 처리하기 전에 특정 작업을 수행하는 강력한 도구입니다. 조건부 컴파일을 통해 코드를 실행 환경에 따라 다르게 처리하거나 불필요한 코드를 제외할 수 있습니다. 본 기사에서는 전처리기를 활용해 안전하고 유지보수 가능한 조건부 코드를 작성하는 방법과 그 이점을 자세히 설명합니다.

목차
  1. 전처리기와 조건부 컴파일의 개요
    1. 전처리기의 역할
    2. 조건부 컴파일의 필요성
  2. 조건부 실행을 위한 전처리기 명령어
    1. 주요 전처리기 명령어
    2. 조건부 실행의 구조
  3. 매크로 정의를 활용한 조건부 코드 작성
    1. 매크로 정의의 기본
    2. 매크로 값과 조건식
    3. 매크로 정의 활용 팁
  4. 안전한 코드 작성을 위한 조건부 컴파일 규칙
    1. 1. 조건부 컴파일 남용을 피하라
    2. 2. 조건은 간결하고 명확하게 작성하라
    3. 3. 중첩 조건부 컴파일을 피하라
    4. 4. 문서화와 주석 추가
    5. 5. 테스트와 검증을 철저히 하라
  5. 조건부 코드에서 디버깅 코드 포함하기
    1. 디버깅 매크로의 기본 개념
    2. 조건부 디버깅 코드 작성
    3. 디버깅 코드 포함의 이점
    4. 디버깅 코드 사용 시 주의점
  6. 프로젝트별 설정과 조건부 컴파일
    1. 프로젝트 설정 파일을 활용한 매크로 관리
    2. 조건부 컴파일과 빌드 스크립트의 결합
    3. 다중 플랫폼 프로젝트에서의 활용
    4. 효율적인 프로젝트 관리 팁
  7. 코드 예제: 플랫폼별 기능 구현
    1. 예제: 운영 체제별로 다른 메시지 출력
    2. 예제: 플랫폼별 파일 경로 처리
    3. 예제: 플랫폼별 기능 활성화
    4. 활용 팁
  8. 조건부 컴파일 관련 흔한 오류와 해결 방법
    1. 1. 매크로 정의 누락
    2. 2. 중첩된 조건부 블록 혼란
    3. 3. 조건부 컴파일의 복잡성 증가
    4. 4. 매크로 이름 충돌
    5. 5. 비활성화된 코드에 숨겨진 오류
    6. 6. 불명확한 조건 사용
    7. 결론
  9. 요약

전처리기와 조건부 컴파일의 개요


전처리기는 컴파일러가 소스 코드를 컴파일하기 전에 수행하는 명령 집합입니다. 이 과정에서 매크로 치환, 파일 포함, 조건부 컴파일 등이 이루어집니다. 조건부 컴파일은 특정 조건에 따라 코드를 포함하거나 제외하는 기능을 제공합니다.

전처리기의 역할


전처리기는 소스 코드를 분석하고 필요한 코드를 준비하는 역할을 합니다. 주요 작업은 다음과 같습니다.

  • 매크로 치환: 정의된 매크로를 실제 값으로 바꿉니다.
  • 파일 포함: #include를 통해 다른 파일을 포함합니다.
  • 조건부 컴파일: 조건에 따라 특정 코드 블록을 컴파일할지 결정합니다.

조건부 컴파일의 필요성


조건부 컴파일은 다음과 같은 경우에 유용합니다.

  • 다중 플랫폼 지원: 서로 다른 운영 체제나 환경에서 특정 코드를 실행해야 할 때.
  • 디버깅 및 테스트: 디버깅 코드나 테스트 코드를 포함하거나 제외할 때.
  • 최적화: 불필요한 코드를 제거하여 최적화할 때.

조건부 컴파일은 코드 유연성을 높이고, 다양한 환경에서 일관성 있게 작동하도록 지원하는 중요한 도구입니다.

조건부 실행을 위한 전처리기 명령어


조건부 실행은 전처리기 명령어를 사용해 코드 블록을 조건적으로 포함하거나 제외하는 기능입니다. 이를 통해 실행 환경에 따라 코드를 유연하게 관리할 수 있습니다.

주요 전처리기 명령어


조건부 실행을 구현하는 데 사용되는 전처리기 명령어는 다음과 같습니다.

#ifdef와 #ifndef

  • #ifdef(if defined): 특정 매크로가 정의되어 있을 때 코드 블록을 포함합니다.
  • #ifndef(if not defined): 특정 매크로가 정의되어 있지 않을 때 코드 블록을 포함합니다.
#ifdef DEBUG
    printf("Debugging is enabled.\n");
#endif

#ifndef RELEASE
    printf("Release mode is not enabled.\n");
#endif

#if, #elif, #else, #endif

  • #if: 조건식이 참일 때 코드 블록을 포함합니다.
  • #elif: 이전 조건이 거짓이고, 새로운 조건식이 참일 때 실행됩니다.
  • #else: 위 조건들이 모두 거짓일 때 실행됩니다.
  • #endif: 조건부 블록의 끝을 나타냅니다.
#if defined(WINDOWS)
    printf("Running on Windows.\n");
#elif defined(LINUX)
    printf("Running on Linux.\n");
#else
    printf("Unknown platform.\n");
#endif

조건부 실행의 구조


전처리기 명령어는 다음과 같은 구조를 가집니다.

  1. 조건 확인: #if나 #ifdef를 통해 조건을 평가합니다.
  2. 실행 코드 포함: 조건이 참인 경우 코드가 포함됩니다.
  3. 다른 조건 처리: #elif와 #else를 사용해 다른 조건을 처리합니다.
  4. 블록 종료: #endif로 조건부 실행을 마칩니다.

전처리기 명령어를 적절히 활용하면, 조건부 실행을 통해 코드를 간결하고 효율적으로 관리할 수 있습니다.

매크로 정의를 활용한 조건부 코드 작성


매크로 정의는 조건부 코드를 구현하는 데 필수적인 도구로, 전처리기 명령어와 결합하여 코드의 유연성과 재사용성을 높일 수 있습니다.

매크로 정의의 기본


#define을 사용해 매크로를 정의하면, 특정 조건을 충족했을 때 해당 매크로를 활용해 코드를 포함하거나 제외할 수 있습니다.

매크로 정의와 조건부 컴파일

#define DEBUG

#ifdef DEBUG
    printf("Debugging is enabled.\n");
#endif

#ifndef RELEASE
    printf("Release mode is not enabled.\n");
#endif


위 코드에서는 DEBUG 매크로가 정의되어 있을 경우 디버깅 관련 코드를 실행합니다.

매크로 값과 조건식


매크로에 값을 부여하고 이를 조건식으로 평가하여 더 복잡한 조건부 코드를 작성할 수 있습니다.

#define VERSION 2

#if VERSION == 1
    printf("Version 1 features enabled.\n");
#elif VERSION == 2
    printf("Version 2 features enabled.\n");
#else
    printf("Unknown version.\n");
#endif


위 코드는 VERSION 매크로 값에 따라 실행되는 코드를 다르게 설정합니다.

매크로 정의 활용 팁

  1. 설정 파일 사용: 환경별 매크로 정의를 한곳에서 관리하면 유지보수가 용이합니다.
  2. 의미 있는 이름 사용: 매크로 이름은 코드의 목적을 명확히 설명해야 합니다.
  3. 불필요한 매크로 최소화: 지나치게 많은 매크로는 코드를 복잡하게 만듭니다.

매크로 정의와 전처리기 명령어를 조합하면, 코드 실행 조건을 세밀하게 제어하고 가독성을 유지할 수 있습니다.

안전한 코드 작성을 위한 조건부 컴파일 규칙


조건부 컴파일은 코드 관리에 유용하지만, 잘못 사용하면 코드의 복잡성과 유지보수 비용을 증가시킬 수 있습니다. 안전하고 효율적인 조건부 코드를 작성하기 위해 다음 규칙을 준수해야 합니다.

1. 조건부 컴파일 남용을 피하라


조건부 컴파일을 지나치게 사용하면 코드를 읽기 어렵게 만듭니다. 불필요한 조건부 블록을 줄이고, 가능한 한 모듈화된 코드 구조를 유지하세요.

// 나쁜 예
#ifdef PLATFORM_A
    // 플랫폼 A 코드
#endif
#ifdef PLATFORM_B
    // 플랫폼 B 코드
#endif

// 좋은 예
void handlePlatform() {
    #ifdef PLATFORM_A
        // 플랫폼 A 코드
    #elif PLATFORM_B
        // 플랫폼 B 코드
    #endif
}

2. 조건은 간결하고 명확하게 작성하라


조건식을 간결하게 유지하면 가독성과 디버깅 효율성이 향상됩니다. 복잡한 조건은 매크로나 상수로 분리하여 의미를 명확히 하세요.

// 복잡한 조건
#if defined(OS_WINDOWS) && !defined(LEGACY_SUPPORT)

// 간결한 조건
#define MODERN_WINDOWS_SUPPORT (defined(OS_WINDOWS) && !defined(LEGACY_SUPPORT))
#if MODERN_WINDOWS_SUPPORT

3. 중첩 조건부 컴파일을 피하라


중첩된 조건부 블록은 코드 읽기와 유지보수를 어렵게 만듭니다. 중첩이 필요한 경우 함수를 나누거나 매크로로 분리하여 가독성을 개선하세요.

// 나쁜 예
#ifdef DEBUG
    #ifdef VERBOSE
        printf("Verbose debugging enabled.\n");
    #endif
#endif

// 좋은 예
#if defined(DEBUG) && defined(VERBOSE)
    printf("Verbose debugging enabled.\n");
#endif

4. 문서화와 주석 추가


조건부 코드 블록에는 명확한 주석을 추가하여 각 조건의 목적을 설명하세요. 이는 코드 리뷰나 유지보수 시 큰 도움이 됩니다.

#ifdef FEATURE_X_ENABLED
    // FEATURE_X: Experimental feature for advanced users
#endif

5. 테스트와 검증을 철저히 하라


모든 조건부 코드 경로가 올바르게 작동하는지 테스트해야 합니다. 특히 다중 플랫폼 환경에서는 각 플랫폼에서 테스트를 수행하여 오류를 예방하세요.

조건부 컴파일 규칙을 잘 준수하면 코드 품질을 유지하면서 다양한 환경에 적응할 수 있는 유연한 코드를 작성할 수 있습니다.

조건부 코드에서 디버깅 코드 포함하기


디버깅 코드는 문제 해결과 프로그램 개발 단계에서 필수적인 요소입니다. 전처리기를 활용해 디버깅 코드를 조건적으로 포함하면, 필요할 때만 활성화할 수 있어 코드의 가독성과 효율성을 높일 수 있습니다.

디버깅 매크로의 기본 개념


디버깅 매크로를 정의하면 디버깅 메시지를 코드에 간단히 추가하거나 제외할 수 있습니다. 일반적으로 DEBUG 매크로를 활용합니다.

#ifdef DEBUG
    #define DEBUG_PRINT(x) printf("DEBUG: %s\n", x)
#else
    #define DEBUG_PRINT(x)
#endif


위 코드는 DEBUG 매크로가 정의된 경우에만 디버깅 메시지를 출력합니다.

조건부 디버깅 코드 작성


디버깅 코드를 선택적으로 포함하여 디버깅 상태와 배포 상태에서 다른 동작을 하도록 만들 수 있습니다.

#include <stdio.h>

#define DEBUG

int main() {
    #ifdef DEBUG
        printf("Debugging mode is ON.\n");
    #else
        printf("Debugging mode is OFF.\n");
    #endif

    DEBUG_PRINT("This is a debug message.");
    return 0;
}


결과적으로 DEBUG가 정의된 경우에만 디버깅 메시지가 출력됩니다.

디버깅 코드 포함의 이점

  1. 코드 배포 시 제거: 디버깅 코드는 전처리 단계에서 제거되므로 배포 코드에 영향을 주지 않습니다.
  2. 문제 해결 용이성: 특정 상황에서 발생하는 문제를 추적하고 분석할 수 있습니다.
  3. 성능 최적화: 디버깅이 필요 없는 경우 디버깅 코드를 제외하여 성능을 유지할 수 있습니다.

디버깅 코드 사용 시 주의점

  • 디버깅 메시지 관리: 너무 많은 디버깅 메시지는 로그를 복잡하게 만듭니다. 중요 메시지를 선택적으로 출력하세요.
  • 환경 설정: 빌드 스크립트나 설정 파일을 사용해 DEBUG 매크로를 관리하세요.
  • 보안 문제: 민감한 정보를 디버깅 메시지에 포함하지 않도록 주의하세요.

디버깅 코드를 전처리기와 결합하여 효과적으로 활용하면 문제를 빠르게 파악하고 해결할 수 있으며, 프로그램 개발 과정이 더 간소화됩니다.

프로젝트별 설정과 조건부 컴파일


조건부 컴파일은 다중 플랫폼이나 다양한 설정이 필요한 프로젝트에서 큰 장점을 제공합니다. 프로젝트별 설정 파일을 활용하면 조건부 컴파일을 체계적으로 관리하고, 환경에 따라 유연하게 작동하는 코드를 작성할 수 있습니다.

프로젝트 설정 파일을 활용한 매크로 관리


프로젝트 설정 파일에서 빌드 환경이나 타겟 플랫폼에 따라 매크로를 정의하거나 설정할 수 있습니다.

  • 플랫폼별 설정: 운영 체제나 하드웨어에 따라 서로 다른 코드를 실행하도록 매크로를 정의합니다.
  • 빌드 모드: 디버그, 릴리스 등 빌드 모드에 따라 매크로를 활성화합니다.

예제: 프로젝트 설정 파일에서 매크로 정의

# Linux 환경
gcc -DLINUX -o program main.c

# Windows 환경
cl /D WINDOWS main.c

조건부 컴파일과 빌드 스크립트의 결합


빌드 스크립트를 사용하여 프로젝트 설정을 자동화하고 매크로를 동적으로 설정할 수 있습니다.

#ifdef LINUX
    printf("Running on Linux.\n");
#elif defined(WINDOWS)
    printf("Running on Windows.\n");
#else
    printf("Unknown platform.\n");
#endif


위 코드에서 LINUX와 WINDOWS 매크로는 빌드 스크립트에 따라 설정됩니다.

다중 플랫폼 프로젝트에서의 활용


다중 플랫폼 프로젝트는 환경에 따라 다른 라이브러리나 기능을 필요로 합니다. 조건부 컴파일을 사용하면 이러한 차이를 효과적으로 처리할 수 있습니다.

#if defined(PLATFORM_X)
    // Platform X 전용 코드
#elif defined(PLATFORM_Y)
    // Platform Y 전용 코드
#else
    // 기본 코드
#endif

효율적인 프로젝트 관리 팁

  1. 중앙화된 설정 파일: 모든 매크로 정의를 한 파일에 모아 관리하면 유지보수가 쉬워집니다.
  2. 빌드 자동화: Makefile, CMake, 또는 다른 빌드 시스템을 사용하여 환경별 매크로 정의를 자동화하세요.
  3. 환경 문서화: 사용 중인 매크로와 설정 파일의 역할을 명확히 문서화하여 팀 간 협업을 원활히 만드세요.

조건부 컴파일과 프로젝트별 설정 파일을 결합하면 다중 환경에서 일관성 있고 안정적인 동작을 보장하는 코드를 효율적으로 작성할 수 있습니다.

코드 예제: 플랫폼별 기능 구현


플랫폼별 기능 구현은 조건부 컴파일의 대표적인 활용 사례입니다. 이를 통해 다양한 환경에서 동일한 소스 코드로 각기 다른 기능을 실행할 수 있습니다. 아래에서는 플랫폼별로 특정 기능을 구현하는 실제 코드 예제를 제공합니다.

예제: 운영 체제별로 다른 메시지 출력


운영 체제에 따라 메시지를 출력하는 코드를 작성합니다.

#include <stdio.h>

// 매크로 정의
#define WINDOWS
// #define LINUX
// #define MACOS

int main() {
    #if defined(WINDOWS)
        printf("Running on Windows.\n");
    #elif defined(LINUX)
        printf("Running on Linux.\n");
    #elif defined(MACOS)
        printf("Running on macOS.\n");
    #else
        printf("Unknown platform.\n");
    #endif

    return 0;
}


위 코드는 매크로 WINDOWS, LINUX, MACOS 중 하나를 정의하여 실행 환경에 따른 메시지를 출력합니다.

예제: 플랫폼별 파일 경로 처리


플랫폼별 파일 경로 규칙을 처리하는 코드입니다.

#include <stdio.h>

int main() {
    #if defined(WINDOWS)
        const char *filePath = "C:\\Program Files\\example.txt";
    #elif defined(LINUX) || defined(MACOS)
        const char *filePath = "/usr/local/example.txt";
    #else
        const char *filePath = "./example.txt";
    #endif

    printf("File path: %s\n", filePath);
    return 0;
}


이 코드는 각 운영 체제의 파일 경로 규칙에 맞는 경로를 설정합니다.

예제: 플랫폼별 기능 활성화


특정 플랫폼에서만 활성화되는 기능을 구현합니다.

#include <stdio.h>

void performPlatformSpecificTask() {
    #ifdef WINDOWS
        printf("Executing Windows-specific task.\n");
    #elif defined(LINUX)
        printf("Executing Linux-specific task.\n");
    #elif defined(MACOS)
        printf("Executing macOS-specific task.\n");
    #else
        printf("Executing default task.\n");
    #endif
}

int main() {
    performPlatformSpecificTask();
    return 0;
}


이 코드는 플랫폼에 따라 다른 기능을 실행하는 함수를 제공합니다.

활용 팁

  1. 테스트 필수: 각 플랫폼에서 코드를 테스트하여 올바르게 작동하는지 확인하세요.
  2. 중복 코드 최소화: 플랫폼별 코드가 중복되지 않도록 공통 코드는 별도로 분리하세요.
  3. 유지보수 용이성: 매크로와 조건부 블록에 주석을 추가하여 의도를 명확히 하세요.

이와 같은 방법을 통해 다양한 환경에서 유연하게 작동하는 프로그램을 작성할 수 있습니다.

조건부 컴파일 관련 흔한 오류와 해결 방법


조건부 컴파일은 유용하지만, 잘못 사용하면 예상치 못한 오류를 초래할 수 있습니다. 여기서는 조건부 컴파일 과정에서 발생할 수 있는 흔한 오류와 이를 해결하는 방법을 다룹니다.

1. 매크로 정의 누락


매크로가 제대로 정의되지 않아 조건부 블록이 실행되지 않는 경우가 발생할 수 있습니다.

#ifdef DEBUG
    printf("Debug mode is on.\n");
#endif


문제: DEBUG 매크로가 정의되지 않았다면, 디버깅 메시지가 출력되지 않습니다.
해결 방법: 매크로를 빌드 스크립트나 소스 코드 상단에 명시적으로 정의하세요.

#define DEBUG


또는 빌드 시 컴파일러 옵션으로 정의할 수 있습니다.

gcc -DDEBUG -o program main.c

2. 중첩된 조건부 블록 혼란


조건부 블록을 중첩할 때 #if, #else, #endif가 정확히 대응되지 않으면 오류가 발생합니다.

#if defined(WINDOWS)
    printf("Windows detected.\n");
#else
    #ifdef LINUX
        printf("Linux detected.\n");
#endif


문제: #else와 #endif가 대응되지 않아 컴파일러가 에러를 발생시킵니다.
해결 방법: 항상 조건부 블록의 구조를 명확히 하고, 중첩된 조건에서 각 블록을 제대로 닫아야 합니다.

#if defined(WINDOWS)
    printf("Windows detected.\n");
#elif defined(LINUX)
    printf("Linux detected.\n");
#endif

3. 조건부 컴파일의 복잡성 증가


너무 많은 조건부 컴파일 블록은 코드를 읽기 어렵게 만듭니다.

#if defined(PLATFORM_A)
    // Code for Platform A
#elif defined(PLATFORM_B)
    // Code for Platform B
#else
    #if defined(FEATURE_X)
        // Code for Feature X
    #endif
#endif


문제: 가독성이 낮아 디버깅과 유지보수가 어려워집니다.
해결 방법: 복잡한 조건은 함수를 나누거나 매크로로 단순화합니다.

#if defined(PLATFORM_A)
    handlePlatformA();
#elif defined(PLATFORM_B)
    handlePlatformB();
#endif

4. 매크로 이름 충돌


다른 라이브러리나 코드와 매크로 이름이 충돌할 수 있습니다.

#define VERSION 1


문제: 동일한 이름의 매크로가 다른 파일에서 재정의되면 예기치 못한 동작이 발생합니다.
해결 방법: 매크로 이름에 프로젝트나 모듈 이름을 접두사로 붙여 고유성을 확보합니다.

#define MYPROJECT_VERSION 1

5. 비활성화된 코드에 숨겨진 오류


조건부로 제외된 코드 블록 내에 컴파일 오류가 존재하는 경우, 실행 환경이 바뀌었을 때 문제가 드러납니다.
문제: #if 조건이 참이 되지 않으면 해당 블록의 코드는 컴파일되지 않으므로 오류가 감지되지 않습니다.
해결 방법: 정기적으로 조건부 블록을 활성화하여 테스트하거나, 코드 리뷰 과정에서 모든 블록을 검증합니다.

6. 불명확한 조건 사용


조건식이 모호하거나 복잡할 경우, 의도한 대로 작동하지 않을 수 있습니다.

#if defined(FEATURE_A) || defined(FEATURE_B) && defined(FEATURE_C)


문제: 연산자 우선순위로 인해 조건이 의도와 다르게 해석될 수 있습니다.
해결 방법: 조건식을 명확히 괄호로 묶어 의도를 명확히 합니다.

#if (defined(FEATURE_A) || defined(FEATURE_B)) && defined(FEATURE_C)

결론


조건부 컴파일 관련 오류를 줄이기 위해 매크로 관리와 코드 테스트를 철저히 하고, 가독성을 높이는 코딩 규칙을 준수하세요. 이를 통해 코드의 안정성과 유지보수성을 강화할 수 있습니다.

요약


C언어 전처리기를 활용한 조건부 코드 실행은 다중 플랫폼 지원, 디버깅 효율성 향상, 코드 최적화 등 다양한 이점을 제공합니다. 조건부 컴파일 명령어와 매크로를 올바르게 사용하면 가독성과 유지보수성을 유지하면서 유연한 코드를 작성할 수 있습니다. 또한, 흔히 발생하는 오류를 예방하고 해결하는 방법을 통해 더 안정적이고 효율적인 프로그램을 구현할 수 있습니다.

C 언어
C언어 전처리기 조건부 실행 코드 안전성
목차
  1. 전처리기와 조건부 컴파일의 개요
    1. 전처리기의 역할
    2. 조건부 컴파일의 필요성
  2. 조건부 실행을 위한 전처리기 명령어
    1. 주요 전처리기 명령어
    2. 조건부 실행의 구조
  3. 매크로 정의를 활용한 조건부 코드 작성
    1. 매크로 정의의 기본
    2. 매크로 값과 조건식
    3. 매크로 정의 활용 팁
  4. 안전한 코드 작성을 위한 조건부 컴파일 규칙
    1. 1. 조건부 컴파일 남용을 피하라
    2. 2. 조건은 간결하고 명확하게 작성하라
    3. 3. 중첩 조건부 컴파일을 피하라
    4. 4. 문서화와 주석 추가
    5. 5. 테스트와 검증을 철저히 하라
  5. 조건부 코드에서 디버깅 코드 포함하기
    1. 디버깅 매크로의 기본 개념
    2. 조건부 디버깅 코드 작성
    3. 디버깅 코드 포함의 이점
    4. 디버깅 코드 사용 시 주의점
  6. 프로젝트별 설정과 조건부 컴파일
    1. 프로젝트 설정 파일을 활용한 매크로 관리
    2. 조건부 컴파일과 빌드 스크립트의 결합
    3. 다중 플랫폼 프로젝트에서의 활용
    4. 효율적인 프로젝트 관리 팁
  7. 코드 예제: 플랫폼별 기능 구현
    1. 예제: 운영 체제별로 다른 메시지 출력
    2. 예제: 플랫폼별 파일 경로 처리
    3. 예제: 플랫폼별 기능 활성화
    4. 활용 팁
  8. 조건부 컴파일 관련 흔한 오류와 해결 방법
    1. 1. 매크로 정의 누락
    2. 2. 중첩된 조건부 블록 혼란
    3. 3. 조건부 컴파일의 복잡성 증가
    4. 4. 매크로 이름 충돌
    5. 5. 비활성화된 코드에 숨겨진 오류
    6. 6. 불명확한 조건 사용
    7. 결론
  9. 요약