C++ -- 宏和模板

‌宏和模板的核心区别在于处理阶段、类型检查和本质机制‌。宏是预处理阶段的文本替换，不进行类型检查；模板是编译阶段的类型参数化，支持类型安全和泛型编程。

宏的处理阶段是：预处理阶段（编译前）

模板的处理阶段是：编译阶段

宏没有类型检查，仅字符串替换；模板有编译期类型检查，保证类型安全

宏不支持重载、特化；模板支持函数/类模板重载、全特化与偏特化

若写成 #define MAX(a, b) (a > b ? a : b)，在 MAX(x++, y++) 中会导致变量被多次递增，产生副作用。

template<typename T>

T max(T a, T b) { return a > b ? a; b; }

编译器会为 int、double 等类型生成对应的 max 函数，且保证类型一致性和调用安全。

使用建议：

‌优先使用模板‌：在 C++ 中应尽可能用模板替代宏，以获得更好的类型安全和可维护性。
‌宏的合理用途 ‌：主要用于条件编译（如 #ifdef NDEBUG）、日志开关、断言等无法用模板实现的场景。

模板的定义通常需要在头文件中完整可见，因为编译器需要在实例化点生成代码。

若将声明放在 .h 而实现放在 .cpp，链接时可能找不到符号。

‌**实例化点（Point of Instantiation）**‌ 是 C++ 模板编程中的一个核心概念，它指的是编译器在源代码中确定模板具体类型并生成相应代码（即实例化）的具体位置。

简单来说，模板本身只是一张"蓝图"，只有当程序在某个地方真正需要使用这个模板的具体版本时，编译器才会在那一刻（或该时刻对应的逻辑位置）根据蓝图生成具体的类或函数代码。这个"生成的位置"就是实例化点。

1. 为什么需要实例化点？

模板代码在被定义时，编译器并不知道 T 具体是什么类型，因此无法生成可执行的机器码。只有当遇到以下情况时，编译器才具备足够的信息来生成代码：

‌隐式实例化‌：代码中调用了模板函数，或创建了模板类的对象，且该操作需要完整的类型定义。
‌显式实例化 ‌：程序员使用 template class MyClass<int>; 强制要求编译器生成代码。

实例化点的存在决定了‌**名称查找（Name Lookup）**‌的规则，特别是对于依赖型名称（dependent names）的解析至关重要。

2. 实例化点的分类与规则

A. 函数模板的实例化点

对于函数模板，实例化点通常位于‌调用该函数的语句之后 ‌，且在当前翻译单元（通常是 .cpp 文件）的全局作用域中。

‌规则‌：如果在一个文件中多次使用同一类型的模板函数，编译器通常只会在第一个使用点（或最后一个使用点，取决于具体实现，但语义上等效）生成一份代码。

cpp 复制代码

template<typename T>

void foo(T t) { /* ... */ }

void bar()
{
    // <--- 这里触发了 foo<int> 的实例化需求
    // 实例化点通常被认为在此调用之后 
    foo(10);  
}

B. 类模板的实例化点

类模板的实例化点稍微复杂一些，分为‌类本身的实例化点 ‌和‌成员函数的实例化点‌。

‌类定义的实例化点 ‌：

当代码需要一个完整类类型时（例如创建对象、获取 sizeof），类模板被实例化。实例化点位于‌使用该类的语句之后‌。
‌成员函数的实例化点‌：
- ‌延迟实例化 ‌：类模板被实例化时，其成员函数‌不会‌立即被实例化。
- ‌触发时机 ‌：只有当某个成员函数被‌调用‌、被取地址、或被明确需要时，该特定的成员函数才会被实例化。
- ‌位置 ‌：成员函数的实例化点位于‌调用该成员函数的语句之后‌。

cpp 复制代码

template<typename T>
class Container 
{
public:
    void add(T item);
    void remove(T item);
};

void test() 
{
    // 1. 实例化 Container<int> 类结构
    Container<int> c;   //此时add和remove的代码尚未生成    
                            
    // 2. 实例化 Container<int>::add(int)
    c.add(5);           //实例化点在此处之后         
                            
    // 如果这行被注释掉，remove 函数永远不会被实例化
    // c.remove(5);         
}

3. 实例化点对"名称查找"的影响（关键难点）

理解实例化点最重要的原因是为了理解‌**两阶段名称查找（Two-Phase Name Lookup）**‌，尤其是在处理依赖型名称时。

在模板定义中，名称分为：

‌非依赖型名称 ‌：不依赖于模板参数。在‌模板定义点‌进行查找。
‌依赖型名称 ‌：依赖于模板参数（如 T::type 或函数参数类型为 T 的函数调用）。在‌实例化点‌进行查找（结合 ADL - 参数依赖查找）。

这意味着： ‌

如果在实例化点之前，引入了新的重载函数或特化，这些新内容可能会影响模板的行为。

cpp 复制代码

#include <iostream>

template<typename T>
void doPrint(T t) 
{
    print(t); // print 是依赖型名称，因为参数类型是 T
}

// 假设这里没有定义 print(int)

void print(int i) 
{
    std::cout << "Integer: " << i << std::endl;
}

int main() 
{
    doPrint(10); // 实例化 doPrint<int>
                 // 在实例化点，编译器通过 ADL 查找 print
                 // 它能找到上面定义的 print(int) 吗？
                 // 答案是可以，因为 print(int) 在实例化点之前可见（在全局作用域）
    return 0;
}

‌注意：如果 print 定义在 doPrint 调用之后，或者在不同的命名空间中且未通过 ADL 找到，编译可能会失败或行为不同。

4. 显式实例化与实例化点

你可以手动控制实例化点，以避免代码膨胀或解决链接问题。

cpp 复制代码

template class Container<int>; // 强制在此处实例化整个类

这告诉编译器："就在这里生成 Container<int> 的所有代码"。这通常放在 .cpp 文件中，以便其他文件可以通过 extern template 来引用它，从而避免在每个包含头文件的 .cpp 中都重复生成代码。

‌显式实例化声明‌：

cpp 复制代码

extern template class Container<int>; // 告诉编译器：别在这里生成代码，去别处找

|-----------|------------------------|-------------------------|
| 概念 | 含义 | 关键影响 |
| ‌实例化点 | 编译器生成模板具体代码的逻辑位置 | 决定依赖型名称的查找范围 |
| ‌函数模板 | 通常在调用点之后 | 每次调用相同类型可能复用同一份代码 |
| ‌类模板 | 类结构在使用点实例化；成员函数在调用点实例化 | 未调用的成员函数不会生成代码（节省空间） |
| 名称查找 | 依赖型名称在实例化点查找 | 允许利用 ADL 找到在模板定义后才声明的函数 |

理解实例化点有助于你解决复杂的模板编译错误，特别是那些涉及"找不到符号"或"名称查找失败"的问题。

ADL ‌ 是 ‌Argument-Dependent Lookup ‌（参数依赖查找）的缩写，在 C++ 中也常被称为 ‌Koenig Lookup‌（由 Andrew Koenig 提出）。

简单来说，ADL 是 C++ 编译器在解析‌未限定函数名 ‌（即没有写 namespace::function 前缀的调用）时采用的一种特殊查找规则：‌编译器不仅会在当前作用域查找函数，还会自动去"函数参数类型"所在的命名空间中查找。