MENU
  1. ホーム
  2. C 언어
  3. C언어에서 매크로 해제하기: #undef의 활용법과 사례

C언어에서 매크로 해제하기: #undef의 활용법과 사례

C 언어

매크로는 C언어에서 코드의 가독성과 재사용성을 높이기 위한 중요한 도구입니다. 그러나 모든 상황에서 매크로가 유효한 것은 아닙니다. 때로는 특정 조건에서 매크로를 비활성화하거나 제거해야 할 필요가 생깁니다. 이를 위해 #undef라는 강력한 지시문이 사용됩니다. 본 기사에서는 매크로 해제의 필요성과 #undef의 활용법을 중심으로 설명하며, 실전 사례를 통해 이를 이해하기 쉽게 풀어갑니다.

목차
  1. 매크로와 `#define`의 기본 개념
    1. `#define`의 기본 구조
    2. 매크로의 장점
    3. 매크로의 한계
  2. `#undef`란 무엇인가
    1. `#undef`의 주요 역할
    2. 기본 구문
    3. 사용 예제
    4. 특징
  3. `#undef`를 사용하는 이유
    1. 매크로 재정의를 위한 사전 처리
    2. 코드 충돌 방지
    3. 조건부 매크로 사용
    4. 매크로의 유효 범위 제한
    5. 디버깅과 유지보수의 편의성
  4. `#undef`의 사용 구문
    1. 기본 사용법
    2. 실전 코드 예제
    3. 조건부 `#undef`
    4. 다중 매크로 관리
    5. 주의 사항
  5. `#undef`의 응용 사례
    1. 1. 조건부 코드 작성
    2. 2. 매크로 이름 재사용
    3. 3. 복잡한 매크로 해제와 재정의
    4. 4. 매크로 비활성화로 코드 디버깅
    5. 5. 플랫폼별 코드 최적화
  6. 매크로 해제 시 주의사항
    1. 1. 정의되지 않은 매크로 해제
    2. 2. 매크로 해제와 재정의 간의 의존성
    3. 3. 전역 매크로 충돌
    4. 4. 매크로 해제 시 코드 가독성 문제
    5. 5. 매크로 해제와 디버깅
    6. 6. 매크로 대체 기술과의 비교
  7. `#undef`를 활용한 디버깅
    1. 1. 매크로 비활성화를 통한 코드 분리
    2. 2. 코드 동작 조건 실험
    3. 3. 전처리 상태 점검
    4. 4. 디버깅 상태 간 전환
    5. 5. 디버깅 로그 제어
  8. 매크로와 대안 기술 비교
    1. 1. 매크로 vs 상수
    2. 2. 매크로 vs 함수
    3. 3. 매크로의 조건부 정의와 대안
    4. 4. 매크로와 인라인 함수
    5. 요약
  9. 요약

매크로와 `#define`의 기본 개념


매크로는 C언어에서 반복적인 코드 패턴을 간단하게 처리하기 위해 사용하는 전처리기 지시문입니다. 매크로는 #define 키워드를 사용해 정의되며, 특정 이름과 해당 이름이 대체될 표현식을 연결합니다.

`#define`의 기본 구조


#define은 간단한 텍스트 대체 작업을 수행합니다. 다음은 기본적인 예입니다:

#define PI 3.14
#define MAX(a, b) ((a) > (b) ? (a) : (b))
  • 첫 번째 매크로는 PI라는 이름을 3.14로 대체합니다.
  • 두 번째 매크로는 두 값을 비교하여 더 큰 값을 반환하는 조건문을 대체합니다.

매크로의 장점

  1. 코드 재사용성: 반복적인 코드 작성 방지.
  2. 유지보수성: 값이나 동작을 중앙에서 관리.
  3. 성능 향상: 함수 호출 오버헤드 없이 텍스트 대체 수행.

매크로의 한계

  • 디버깅 어려움: 디버깅 중 매크로 확장 결과를 추적하기 어려움.
  • 가독성 저하: 복잡한 매크로는 코드 가독성을 해칠 수 있음.
  • 타입 안전성 부족: 매크로는 타입 검사를 수행하지 않음.

매크로는 단순하면서도 강력하지만, 적절히 관리하지 않으면 유지보수성과 디버깅에서 문제가 될 수 있습니다. 이러한 이유로, 때로는 매크로를 해제하거나 재정의하는 것이 필요하며, 이를 위해 #undef가 사용됩니다.

`#undef`란 무엇인가


#undef는 C언어의 전처리기 지시문 중 하나로, 이전에 정의된 매크로를 해제하는 데 사용됩니다. 매크로를 해제하면 해당 매크로는 더 이상 유효하지 않으며, 이후의 코드에서 정의되지 않은 상태로 처리됩니다.

`#undef`의 주요 역할

  • 매크로의 비활성화: 특정 매크로 정의를 삭제하여 이후 코드에서 무효화.
  • 재정의 준비: 기존 매크로를 해제하고 새로운 정의를 적용 가능.
  • 코드 충돌 방지: 동일한 이름의 매크로 정의로 인한 충돌 해결.

기본 구문


#undef의 사용법은 매우 간단합니다.

#undef MACRO_NAME

위 코드는 MACRO_NAME으로 정의된 매크로를 해제합니다.

사용 예제

#include <stdio.h>

#define VALUE 10

int main() {
    printf("Before undef: %d\n", VALUE);

    #undef VALUE  // 매크로 해제
    #define VALUE 20  // 새 정의
    printf("After undef and redefine: %d\n", VALUE);

    return 0;
}

출력:

Before undef: 10  
After undef and redefine: 20

특징

  • #undef는 전처리기 단계에서만 동작하며, 런타임에 영향을 미치지 않습니다.
  • 매크로가 해제된 후에는 동일한 이름의 새로운 정의가 가능해 유연한 코드 작성에 도움을 줍니다.

#undef는 매크로를 동적으로 관리하고 코드 충돌을 방지하는 중요한 도구입니다.

`#undef`를 사용하는 이유


#undef를 사용하는 이유는 코드의 유연성과 유지보수성을 높이기 위해서입니다. 매크로는 전역적으로 작용하므로, 필요에 따라 특정 매크로를 비활성화하거나 재정의해야 하는 경우가 자주 발생합니다. #undef는 이러한 요구를 충족시키는 도구로, 다양한 상황에서 유용하게 사용됩니다.

매크로 재정의를 위한 사전 처리


하나의 매크로 정의가 이후 코드에서 더 이상 필요하지 않거나, 새로운 정의로 대체되어야 할 때 사용됩니다.
예를 들어, 환경 설정이나 특정 라이브러리의 매크로 값을 상황에 따라 다르게 설정해야 할 때 유용합니다.

#define DEBUG 1
// Some debug-related code
#undef DEBUG
#define DEBUG 0  // Re-define for production

코드 충돌 방지


매크로 이름은 전역적으로 작동하므로, 다른 모듈이나 라이브러리에서 동일한 이름의 매크로가 정의되어 있을 경우 충돌이 발생할 수 있습니다. #undef는 이러한 충돌을 해결하는 데 사용됩니다.

#define PI 3.14
// ... 포함된 라이브러리에서 다른 PI 정의가 있을 경우
#undef PI
#define PI 3.14159  // 정확한 값으로 재정의

조건부 매크로 사용


특정 조건에서 매크로를 해제하여 코드의 동작을 동적으로 제어할 수 있습니다.

#ifdef FEATURE_ENABLED
    #undef FEATURE_ENABLED
#endif

매크로의 유효 범위 제한


매크로가 특정 블록 내에서만 유효하도록 범위를 제한하는 데 사용됩니다. 이렇게 하면 다른 코드에서 해당 매크로의 영향을 받지 않도록 할 수 있습니다.

#define TEMP_VAR 100
// 특정 작업 수행
#undef TEMP_VAR

디버깅과 유지보수의 편의성


매크로를 해제함으로써 디버깅 시 불필요한 매크로 확장을 방지하거나, 명확한 코드 분석이 가능합니다.

#undef는 코드의 충돌 방지와 유연한 매크로 관리를 위해 중요한 역할을 하며, 다양한 개발 상황에서 유용하게 활용될 수 있습니다.

`#undef`의 사용 구문


#undef는 특정 매크로를 해제하는 간단한 전처리기 지시문입니다. 구문은 명료하며, 기존 매크로의 정의를 제거하여 이후 코드에서 해당 매크로가 정의되지 않은 상태로 동작하도록 만듭니다.

기본 사용법


#undef의 기본 구문은 다음과 같습니다:

#undef MACRO_NAME

여기서 MACRO_NAME은 이전에 정의된 매크로 이름입니다. #undef가 실행되면, 해당 매크로는 더 이상 유효하지 않습니다.

실전 코드 예제

#include <stdio.h>

#define MESSAGE "Hello, World!"  // 매크로 정의

int main() {
    printf("%s\n", MESSAGE);  // 매크로 사용

    #undef MESSAGE  // 매크로 해제
    // printf("%s\n", MESSAGE);  // 컴파일 오류: MESSAGE가 정의되지 않음

    #define MESSAGE "Hello, C Programming!"  // 새 정의
    printf("%s\n", MESSAGE);  // 새로운 매크로 사용

    return 0;
}

출력 결과:

Hello, World!  
Hello, C Programming!

조건부 `#undef`


매크로가 정의된 경우에만 해제하려면 #ifdef와 함께 사용할 수 있습니다:

#ifdef DEBUG
    #undef DEBUG
#endif

이 코드는 DEBUG 매크로가 정의된 경우에만 이를 해제합니다.

다중 매크로 관리


여러 매크로를 한 번에 관리하기 위해서는 각 매크로를 개별적으로 해제해야 합니다:

#undef MACRO1
#undef MACRO2
#undef MACRO3

주의 사항

  1. #undef는 매크로가 정의되지 않은 상태에서 실행되어도 에러를 발생시키지 않습니다.
  2. 매크로 해제 후 동일 이름으로 새로 정의하지 않으면, 해당 이름을 사용할 경우 컴파일 오류가 발생할 수 있습니다.

#undef의 간단한 구문과 유연한 사용법은 복잡한 매크로 관리에서 매우 유용하며, 코드의 유지보수성과 가독성을 높이는 데 기여합니다.

`#undef`의 응용 사례


#undef는 매크로를 유연하게 관리할 수 있는 도구로, 복잡한 코드 상황에서 다양한 방식으로 활용됩니다. 이를 통해 코드의 유지보수성과 가독성을 높일 수 있습니다.

1. 조건부 코드 작성


특정 조건에 따라 매크로를 해제하고 다른 매크로를 정의하는 방법은 코드의 유연성을 높이는 데 유용합니다.

#include <stdio.h>

#define DEBUG

int main() {
    #ifdef DEBUG
        #undef DEBUG
        #define DEBUG 0  // 다른 환경에 맞게 매크로 재정의
    #endif

    #if DEBUG
        printf("Debug mode is ON\n");
    #else
        printf("Debug mode is OFF\n");
    #endif

    return 0;
}

출력:

Debug mode is OFF

2. 매크로 이름 재사용


다양한 모듈에서 동일한 매크로 이름을 사용하는 경우, 충돌을 방지하기 위해 #undef를 활용합니다.

#include <stdio.h>

#define VALUE 100
// 모듈 1 코드
#undef VALUE  // 이전 정의 해제
#define VALUE 200  // 새 정의 적용

// 모듈 2 코드
int main() {
    printf("VALUE: %d\n", VALUE);  // 모듈 2에서 재정의된 값 사용
    return 0;
}

출력:

VALUE: 200

3. 복잡한 매크로 해제와 재정의


매크로가 여러 단계의 정의를 가지고 있을 때 #undef를 활용해 단계적으로 관리합니다.

#include <stdio.h>

#define STEP 1
#define VALUE (STEP * 10)

int main() {
    printf("Initial VALUE: %d\n", VALUE);

    #undef STEP
    #define STEP 2  // 새로운 단계 정의
    printf("Modified VALUE: %d\n", VALUE);

    return 0;
}

출력:

Initial VALUE: 10  
Modified VALUE: 20

4. 매크로 비활성화로 코드 디버깅


매크로를 해제하여 특정 코드 블록을 임시로 비활성화하거나 디버깅 목적으로 활용할 수 있습니다.

#include <stdio.h>

#define ENABLE_FEATURE

int main() {
    #ifdef ENABLE_FEATURE
        printf("Feature is enabled\n");
    #endif

    #undef ENABLE_FEATURE

    #ifdef ENABLE_FEATURE
        printf("This will not print\n");
    #endif

    return 0;
}

출력:

Feature is enabled

5. 플랫폼별 코드 최적화


다른 운영 체제나 플랫폼에서 동일한 매크로 이름을 다르게 정의해야 할 때 유용합니다.

#ifdef _WIN32
    #undef CONFIG
    #define CONFIG "Windows Configuration"
#elif __linux__
    #undef CONFIG
    #define CONFIG "Linux Configuration"
#endif

#undef는 복잡한 소프트웨어 개발 환경에서 유연한 매크로 관리와 코드 최적화에 필수적인 도구입니다. 이를 활용해 프로젝트를 더 간결하고 유지보수하기 쉽게 만들 수 있습니다.

매크로 해제 시 주의사항


#undef를 사용할 때는 매크로의 특성과 코드 동작에 대한 이해가 중요합니다. 매크로 해제는 간단하지만, 적절히 관리하지 않으면 예기치 않은 오류나 비효율적인 코드 작성으로 이어질 수 있습니다.

1. 정의되지 않은 매크로 해제


#undef는 매크로가 정의되지 않은 상태에서도 에러를 발생시키지 않습니다. 그러나 이를 무작위로 사용하면 디버깅 중 혼란을 초래할 수 있습니다.

예시:

#undef NON_EXISTENT_MACRO  // 오류는 없으나, 의미 없는 동작

해결 방법:
항상 매크로가 정의되었는지 확인한 후 해제합니다.

#ifdef MACRO_NAME
    #undef MACRO_NAME
#endif

2. 매크로 해제와 재정의 간의 의존성


매크로 해제 후 재정의하지 않으면 의존성이 있는 코드는 컴파일 오류를 발생시킬 수 있습니다.

예시:

#define VALUE 100
#undef VALUE
int x = VALUE;  // 컴파일 오류: VALUE가 정의되지 않음

해결 방법:
매크로가 필요한 모든 위치에서 정의 상태를 보장합니다.

3. 전역 매크로 충돌


매크로는 전역적으로 작동하므로, 다른 파일이나 라이브러리에서 동일한 이름을 사용할 경우 충돌이 발생할 수 있습니다.

예시:

#define BUFFER_SIZE 1024
#include "some_library.h"  // 동일한 BUFFER_SIZE 정의 충돌 가능
#undef BUFFER_SIZE

해결 방법:

  • 매크로 이름에 고유 접두사를 추가합니다.
  • 필요한 경우 충돌을 방지하기 위해 #undef를 사용합니다.

4. 매크로 해제 시 코드 가독성 문제


#undef가 남용되면 코드가 복잡해지고 가독성이 떨어질 수 있습니다.

예시:

#define DEBUG
#undef DEBUG
#define DEBUG
#undef DEBUG

해결 방법:
매크로 정의와 해제는 명확한 목적에 따라 최소화합니다.

5. 매크로 해제와 디버깅


디버깅 중 매크로가 해제된 상태인지 확인하지 않으면 예상치 못한 동작을 유발할 수 있습니다.

해결 방법:

  • 전처리 단계에서 매크로 상태를 출력합니다.
#ifdef DEBUG
    #pragma message("DEBUG is defined")
#else
    #pragma message("DEBUG is not defined")
#endif

6. 매크로 대체 기술과의 비교


매크로 해제가 필요 없는 대체 기술(예: 함수, 상수)도 고려해야 합니다. 매크로의 복잡성이 높아질수록 이러한 대안을 사용하는 것이 더 나을 수 있습니다.

#undef는 강력한 도구이지만, 사용 시 주의사항을 준수해야 안전하고 효율적인 코드 작성을 보장할 수 있습니다.

`#undef`를 활용한 디버깅


#undef는 디버깅 과정에서 매크로를 관리하고 코드 동작을 조정하는 데 유용한 도구입니다. 매크로를 해제하거나 재정의함으로써 특정 코드 경로를 테스트하거나 문제를 파악할 수 있습니다.

1. 매크로 비활성화를 통한 코드 분리


디버깅 시 불필요한 코드 경로를 비활성화하기 위해 #undef를 사용할 수 있습니다. 이를 통해 디버깅 대상 코드만 실행되도록 조정할 수 있습니다.

#include <stdio.h>

#define DEBUG_MODE

int main() {
    #ifdef DEBUG_MODE
        printf("Debugging is enabled\n");
        // 디버깅 코드 실행
        #undef DEBUG_MODE  // 디버깅 모드 비활성화
    #endif

    #ifdef DEBUG_MODE
        printf("This code will not execute\n");
    #else
        printf("Debugging is disabled\n");
    #endif

    return 0;
}

출력:

Debugging is enabled  
Debugging is disabled

2. 코드 동작 조건 실험


#undef를 활용해 다양한 매크로 설정을 테스트하여 코드의 동작을 실험할 수 있습니다.

#include <stdio.h>

#define FEATURE_ENABLED
#define LOG_LEVEL 1

int main() {
    #ifdef FEATURE_ENABLED
        printf("Feature is enabled\n");
        #undef FEATURE_ENABLED
    #endif

    #ifdef FEATURE_ENABLED
        printf("This won't print\n");
    #endif

    #undef LOG_LEVEL
    #define LOG_LEVEL 2  // 다른 로그 레벨로 재정의

    printf("Log level: %d\n", LOG_LEVEL);

    return 0;
}

출력:

Feature is enabled  
Log level: 2

3. 전처리 상태 점검


전처리 상태를 점검하여 매크로 정의 여부를 명확히 확인할 수 있습니다. #undef를 사용하면 매크로를 해제한 후 상태를 다시 점검할 수 있습니다.

#define TEST_MACRO

#ifdef TEST_MACRO
    #pragma message("TEST_MACRO is defined")
    #undef TEST_MACRO
#endif

#ifndef TEST_MACRO
    #pragma message("TEST_MACRO is not defined")
#endif

출력 (컴파일 시):

TEST_MACRO is defined  
TEST_MACRO is not defined

4. 디버깅 상태 간 전환


다양한 디버깅 상태를 관리하기 위해 #undef와 재정의를 활용합니다.

#define DEBUG_LEVEL 1

int main() {
    #if DEBUG_LEVEL == 1
        printf("Basic Debugging\n");
    #elif DEBUG_LEVEL == 2
        printf("Advanced Debugging\n");
    #endif

    #undef DEBUG_LEVEL
    #define DEBUG_LEVEL 2  // 디버깅 수준 변경

    #if DEBUG_LEVEL == 1
        printf("Basic Debugging\n");
    #elif DEBUG_LEVEL == 2
        printf("Advanced Debugging\n");
    #endif

    return 0;
}

출력:

Basic Debugging  
Advanced Debugging

5. 디버깅 로그 제어


로그 출력을 매크로로 제어한 후 필요 시 #undef로 로그 출력을 동적으로 비활성화할 수 있습니다.

#define LOG_ENABLED

#ifdef LOG_ENABLED
    #define LOG(msg) printf("[LOG]: %s\n", msg)
#else
    #define LOG(msg)
#endif

int main() {
    LOG("This is a debug log.");
    #undef LOG_ENABLED
    LOG("This log won't appear.");
    return 0;
}

출력:

[LOG]: This is a debug log.

#undef를 활용하면 디버깅 과정에서 매크로 상태를 동적으로 제어할 수 있어 코드의 문제를 효과적으로 파악하고 수정할 수 있습니다.

매크로와 대안 기술 비교


C언어에서 매크로는 효율적인 코드 작성에 유용하지만, 복잡성과 디버깅 어려움 등으로 인해 제한이 따릅니다. 매크로와 대안 기술(함수, 상수)을 비교하여 상황에 맞는 최적의 선택을 도출할 수 있습니다.

1. 매크로 vs 상수


매크로

  • 장점:
  • 텍스트 치환 방식으로 처리되어 컴파일 시간에 추가적인 메모리 할당이 발생하지 않음.
  • 복잡한 표현식 정의 가능.
  • 단점:
  • 디버깅이 어려움(디버거에서 추적 불가).
  • 타입 안전성이 부족.

상수

  • 장점:
  • 컴파일러의 타입 검사를 받음(타입 안전성 보장).
  • 디버깅이 용이.
  • 단점:
  • 상수는 메모리를 점유하므로 일부 상황에서 성능 저하 가능.

비교 예제:

// 매크로 사용
#define PI 3.14

// 상수 사용
const double pi = 3.14;

권장: 상수는 타입 안전성과 디버깅 편의성을 제공하므로, 단순 값을 정의할 때는 상수를 사용하는 것이 좋습니다.

2. 매크로 vs 함수


매크로

  • 장점:
  • 함수 호출 오버헤드가 없음.
  • 인라인 치환으로 성능 향상.
  • 단점:
  • 복잡한 매크로는 가독성을 저하시키고, 디버깅이 어렵다.
  • 예기치 않은 확장 문제가 발생할 수 있음.

함수

  • 장점:
  • 타입 안전성과 가독성 보장.
  • 함수는 스택 프레임을 관리하여 코드 안전성을 높임.
  • 단점:
  • 함수 호출 오버헤드 발생 가능.

비교 예제:

// 매크로
#define MAX(a, b) ((a) > (b) ? (a) : (b))

// 함수
int max(int a, int b) {
    return (a > b) ? a : b;
}

권장: 복잡한 작업이나 반복적인 호출이 필요한 경우 함수 사용을 선호해야 합니다.

3. 매크로의 조건부 정의와 대안


매크로

  • 조건에 따라 코드 블록을 활성화하거나 비활성화하는 데 유용.

대안: if 조건문과 상수 또는 변수 조합 사용.

#ifdef FEATURE_ENABLED
    printf("Feature is enabled\n");
#else
    printf("Feature is disabled\n");
#endif

// 대안
const bool feature_enabled = true;
if (feature_enabled) {
    printf("Feature is enabled\n");
} else {
    printf("Feature is disabled\n");
}

권장: 조건부 로직이 간단한 경우 상수나 변수로 대체하여 가독성을 높이는 것이 좋습니다.

4. 매크로와 인라인 함수


C99부터는 inline 키워드를 지원하여 인라인 함수 사용이 가능해졌습니다.

비교:

  • 매크로는 텍스트 치환으로 처리되지만, 인라인 함수는 함수처럼 타입 검사를 받음.
  • 매크로는 간단한 경우에 적합하며, 인라인 함수는 복잡한 작업에서 더 안전함.

예제:

// 매크로
#define SQUARE(x) ((x) * (x))

// 인라인 함수
inline int square(int x) {
    return x * x;
}

권장: 복잡한 연산에는 인라인 함수를 사용하여 디버깅과 코드 안정성을 확보합니다.

요약

  • 단순 값 정의에는 상수를 사용.
  • 복잡한 조건문이나 연산에는 함수나 인라인 함수를 선호.
  • 매크로는 최소화하여 디버깅 및 유지보수를 용이하게 해야 함.

매크로는 강력한 도구이지만, 적절한 대안을 활용하면 코드 품질과 안정성을 더욱 높일 수 있습니다.

요약


본 기사에서는 C언어에서 매크로 해제를 위한 #undef 지시문의 개념과 활용 방법을 살펴보았습니다. 매크로의 재정의, 조건부 코드 작성, 충돌 방지, 디버깅 등을 효과적으로 관리할 수 있는 #undef는 코드의 유연성과 유지보수성을 높이는 데 중요한 역할을 합니다. 또한, 매크로의 대안 기술인 상수, 함수, 인라인 함수와의 비교를 통해 최적의 선택을 도출할 수 있는 기준을 제공했습니다. 이를 통해 더 안전하고 효율적인 코드를 작성할 수 있습니다.

C 언어
C언어 매크로 코딩팁
목차
  1. 매크로와 `#define`의 기본 개념
    1. `#define`의 기본 구조
    2. 매크로의 장점
    3. 매크로의 한계
  2. `#undef`란 무엇인가
    1. `#undef`의 주요 역할
    2. 기본 구문
    3. 사용 예제
    4. 특징
  3. `#undef`를 사용하는 이유
    1. 매크로 재정의를 위한 사전 처리
    2. 코드 충돌 방지
    3. 조건부 매크로 사용
    4. 매크로의 유효 범위 제한
    5. 디버깅과 유지보수의 편의성
  4. `#undef`의 사용 구문
    1. 기본 사용법
    2. 실전 코드 예제
    3. 조건부 `#undef`
    4. 다중 매크로 관리
    5. 주의 사항
  5. `#undef`의 응용 사례
    1. 1. 조건부 코드 작성
    2. 2. 매크로 이름 재사용
    3. 3. 복잡한 매크로 해제와 재정의
    4. 4. 매크로 비활성화로 코드 디버깅
    5. 5. 플랫폼별 코드 최적화
  6. 매크로 해제 시 주의사항
    1. 1. 정의되지 않은 매크로 해제
    2. 2. 매크로 해제와 재정의 간의 의존성
    3. 3. 전역 매크로 충돌
    4. 4. 매크로 해제 시 코드 가독성 문제
    5. 5. 매크로 해제와 디버깅
    6. 6. 매크로 대체 기술과의 비교
  7. `#undef`를 활용한 디버깅
    1. 1. 매크로 비활성화를 통한 코드 분리
    2. 2. 코드 동작 조건 실험
    3. 3. 전처리 상태 점검
    4. 4. 디버깅 상태 간 전환
    5. 5. 디버깅 로그 제어
  8. 매크로와 대안 기술 비교
    1. 1. 매크로 vs 상수
    2. 2. 매크로 vs 함수
    3. 3. 매크로의 조건부 정의와 대안
    4. 4. 매크로와 인라인 함수
    5. 요약
  9. 요약