【穿越Effective C++】条款02：尽量以const, enum, inline替换#define

这个条款的核心思想是：优先使用编译器而非预处理器 。#define是预处理器指令，在编译前进行简单的文本替换，这会带来多种问题。我们应该用C++语言特性来替代它。

---

核心思想思维导图

---

详细解析

1. 为什么要避免#define？

问题1：符号表缺失

#define PI 3.14159

• 预处理器将代码中所有PI替换为3.14159
• 编译器永远看不到PI这个符号 ，调试时错误信息只会显示3.14159
• 不利于调试和错误定位

问题2：类型安全缺失

• #define不进行类型检查，只是文本替换
• 可能引发难以发现的类型相关错误

问题3：作用域问题

• #define不受命名空间、类作用域限制
• 容易造成命名污染和冲突

问题4：边际效应（函数宏）

#define MAX(a, b) ((a) > (b) ? (a) : (b))
int x = 5, y = 3;
int z = MAX(++x, y);  // 展开后：((++x) > (y) ? (++x) : (y))
                      // x可能被递增两次！

2. 解决方案详解

2.1 用const替换常量宏

普通常量：

// 不好的做法
#define PI 3.14159
#define AUTHOR "Scott Meyers"

// 好的做法
const double Pi = 3.14159;           // 类型安全，编译器可见
const char* const Author = "Scott Meyers";  // 常量指针，指向常量字符串

类专属常量：

class GamePlayer {
private:
    // 好的做法：类内静态常量
    static const int NumTurns = 5;    // 常量声明
    int scores[NumTurns];             // 使用常量
    // ...
};

// 需要在实现文件中定义（如果取地址或某些编译器需要）
const int GamePlayer::NumTurns;       // 定义

2.2 用enum替换常量宏

当编译器不支持类内初始化时：

class GamePlayer {
private:
    enum { NumTurns = 5 };           // "enum hack"技巧
    int scores[NumTurns];            // 合法使用
    // ...
};

enum hack的优势：

• 行为像#define（不能取地址，不会分配内存）
• 阻止别人获取指针或引用
• 模板元编程基础技巧

2.3 用inline替换函数宏

函数宏的问题：

// 危险的宏函数
#define CALL_WITH_MAX(a, b) f((a) > (b) ? (a) : (b))

// 使用时的意外行为
int a = 5, b = 0;
CALL_WITH_MAX(++a, b);    // a递增两次
CALL_WITH_MAX(++a, b+10); // a递增一次

安全的inline函数：

// 模板内联函数 - 类型安全，无边际效应
template<typename T>
inline void callWithMax(const T& a, const T& b) {
    f(a > b ? a : b);
}

// 使用安全
int a = 5, b = 0;
callWithMax(++a, b);      // a只递增一次，行为可预测

---

关键总结与最佳实践

1. 简单常量 → 使用const对象
2. 类内常量 → 使用static const成员或enum
3. 函数宏 → 使用inline函数或模板函数
4. 字符串常量 → 使用const char* const

例外情况 ：#define在条件编译、平台特定代码、字符串化操作（#）和令牌连接（##）中仍有其价值，但这些属于特殊情况。

核心记忆点 ：让编译器看到你的代码，而不是让预处理器盲目替换。使用C++语言特性获得类型安全、作用域控制和更好的调试体验。