你是否遇到过这样的疑惑: 明明函数参数类型写的是 T&& (右值引用) ，为什么编译器还是调用了拷贝构造函数? ** 或者，写模板时到底该用 move 还是 forward? **

本文将基于实战场景，总结 C++ 移动语义中最核心的规则与陷阱.

std::move 问题引入

让我们考虑以下问题:

BASIC_JSON_TEMPLATE 
void BASIC_JSON_TYPE::push_back(basic_json&& val) 
{ 
 	as_array().emplace_back(std::move(val)); 
}

在这段代码中, std::move是否必要? 如果只传入val效果是否相同?

简短的回答是: **std::move 是绝对必要的. 如果去掉它，效果完全不同. **

虽然函数参数 val 的类型是 basic_json&& (右值引用) ，但在函数体内部，val 这个变量本身是有名字的.

在 C++ 中有一条核心规则: **具名变量 (Named Variable) 永远是左值 (Lvalue) ，即使它的类型是右值引用 (Rvalue Reference) . **

这是一个非常深刻且容易混淆的概念，触及了 C++ 中 类型 (Type) 与 值类别 (Value Category) 之间的核心区别.

核心矛盾: 类型 vs. 身份

此时的困惑在于混淆了以下两个概念:

1. 变量的类型: val 的类型是 basic_json&& (右值引用) . 这意味着它指向一个右值 (临时的, 可移动的对象) .
2. 变量的表达式属性 (值类别) **: 在函数体内部，val 这个名字本身**是一个左值.

**为什么? ** 因为 val 在这个函数体内是有名字的，它是“持久”存在的. 你可以在第一行用它，在第二行用它，在第三行还用它.

• 只要你有名字，你就是左值. ** 编译器认为你可能在后面还会用到它，所以默认不给你移动，而是拷贝** (因为拷贝是安全的，原对象还在) .
• 如果你确定“我这行代码用完就不再用它了”，你必须显式地使用 std::move(val). 这相当于你签了一份“免责声明”，告诉编译器: “我知道我在做什么，把它转成右值吧，后面坏了我负责. ”

也就是说:

• 类型是 T&& 只代表“它可以被移动”.
• 名字本身 代表“它在当前作用域还活着”.
• 要想真正触发移动，必须用 std::move() 剥夺它的名字属性，将其转化为一个亡值 (Xvalue), 即一个临时的右值表达式.

无论它的类型写得多么花哨 (比如 T&&, const T&&) ，只要你在函数体里能用名字 val 访问它，它就是左值. 因为编译器认为: “既然你有名字，说明你还要被使用，所以我不能背着你偷偷把你移走”.

何时显式调用std::move?

只需记住以下黄金法则:

除编译器对函数内局部变量的返回值优化(RVO)的场景外, 所有想要移动一个具名变量或引用的场景都应该显式调用std::move.

我们可以把场景分为两类: 传递 和 返回.

场景 A: 传递 (Passing) —— 必须 move

当你手里有一个具名的对象 (无论是局部变量还是参数) ，你想把它交给另一个函数 (如 vector::push_back) ，并且你不再需要它了:

• 必须显示调用 std::move.
• 这就是你刚才遇到的 push_back(val) vs push_back(std::move(val)) 的情况.

场景 B: 返回 (Returning) —— 不要 move (绝大多数情况)

当你返回一个函数内的局部变量时:

basic_json make_json() {
    basic_json j;
    // ... 对 j 进行操作 ...
    
    return j; // 不要写 std::move(j)!
}

• RVO/NRVO (返回值优化): 编译器会直接在调用者的栈上构造 j，完全消除拷贝和移动. 这是最高效的 (Zero Copy/Move) .
• 隐式移动 (Implicit Move): 即使编译器太笨无法进行 RVO，C++ 标准也规定: 如果返回的是局部对象，编译器必须自动把它视为右值去尝试移动.
• 画蛇添足: 如果你写了 return std::move(j);，你反而破坏了 RVO 的条件，强制编译器放弃“零拷贝”，转而去执行一次“移动构造”. 虽然移动很快，但 RVO 是什么都不做，显然 RVO 更快.

特例: 当返回的是函数参数时——此时需要显式 move

有一个场景虽然是“返回”，但不能依赖 RVO，需要显式 std::move: 当返回的是函数参数时 (特别是右值引用类型的参数) .

// push_back 场景是把参数传递给另一个函数 -> 需要 move (正确)
void push_back(basic_json&& val) {
    vec.emplace_back(std::move(val)); 
}

// 如果你的场景是直接把这个参数“原路返回” -> 也需要 move
basic_json pass_through(basic_json&& val) {
    // return val;            // 错误！val 是左值，会触发拷贝构造 (如果 basic_json 有拷贝构造的话) 
    return std::move(val);    // 正确！参数不是局部变量，无法触发 NRVO，必须显式 move
}

总结

std::move 的实现

template<typename _Tp>
_GLIBCXX_NODISCARD
constexpr typename std::remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept
{ 
    return static_cast<typename std::remove_reference<_Tp>::type&&>(__t);
}

std::forward 引入: 为什么我们需要 std::forward? (痛点)

假设你写了一个泛型函数 wrapper，它的作用只是把参数透传给另一个函数 process.

void process(int& x)  { std::cout << "处理左值 (Copy)" << std::endl; }
void process(int&& x) { std::cout << "处理右值 (Move)" << std::endl; }

template <typename T>
void wrapper(T&& arg) {
    // arg 在这里有名字，所以它是左值！
    // 无论外面传入的是什么，这里调用的永远是 process(int&)
    process(arg); 
}

int main() {
    int a = 1;
    wrapper(a); // 传入左值 -> 期望调用左值版本 -> 实际调用左值版本 (OK)
    wrapper(1); // 传入右值 -> 期望调用右值版本 -> 实际调用左值版本 (性能损失!)
}

问题在于: 正如我们在上一个问题中讨论的，参数 arg 虽然类型可能是 int&&，但因为它有名字，在 wrapper 内部它变成了左值. 如果我们不做处理直接传给 process，右值的信息就丢失了，永远无法触发 process 的移动语义版本.

**尝试用 std::move 修复? ** 如果写成 process(std::move(arg))，那么当你传入左值 a 时，wrapper 也会强制把它 move 掉. 这很危险 (外部的 a 可能被意外掏空) .

我们需要一种机制，能够“完美地”还原参数最原始的属性 (是左值就传左值，是右值就传右值) . 这就是 完美转发 (Perfect Forwarding).

std::forward 的工作原理及实现

std::forward 配合 万能引用 (Universal Reference) (即模板中的 T&&) 使用.

/**
*  @brief  Forward an lvalue.
*  @return The parameter cast to the specified type.
*
*  This function is used to implement "perfect forwarding".
*/
template<typename _Tp>
_GLIBCXX_NODISCARD
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{ 
    return static_cast<_Tp&&>(__t);
}

/**
*  @brief  Forward an rvalue.
*  @return The parameter cast to the specified type.
*
*  This function is used to implement "perfect forwarding".
*/
template<typename _Tp>
_GLIBCXX_NODISCARD
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
    static_assert(!std::is_lvalue_reference<_Tp>::value,
    "std::forward must not be used to convert an rvalue to an lvalue");
    // 上面这行代码在阻止你做一件蠢事: 试图把一个右值当作左值转发. 
    // 例如: `std::forward<int&>(1)` -> 导致悬垂引用风险(左值引用实际引用了一个右值)!
    return static_cast<_Tp&&>(__t);
}

上述实现中, 第一个重载版本是在写泛型函数时 99% 遇到的情况 (即转发一个左值 (不要忘了, 右值引用也是左值!) ); 第二个重载版本允许了 std::forward<int>(1) 或 std::forward<T>(std::move(arg)) 的使用, 实际使用较少.

引用折叠规则

std::forward 的实现依赖于 C++ 的 引用折叠 (Reference Collapsing) 规则:

1. T& & → T& (左值引用 + 左值引用 → 左值引用)
2. T& && → T& (左值引用 + 右值引用 → 左值引用)
3. T&& & → T& (右值引用 + 左值引用 → 左值引用)
4. T&& && → T&& (右值引用 + 右值引用 → 右值引用)

简单理解:

• “只要有左值引用，就折叠成左值引用”.
• “只有当所有引用都是右值引用时，结果才是右值引用”.

使用

template <typename T>
void wrapper(T&& arg) {
    // 这里的 T 会保存原始参数的左值/右值信息
    process(std::forward<T>(arg)); 
}

1. 传入左值 wrapper(a):
   • T 被推导为 int&.
   • std::forward<int&>(arg) 会返回 int& (左值).
   • process 接收到左值.
2. 传入右值 wrapper(1):
   • T 被推导为 int (或者 int&&，取决于编译器实现细节，但效果一致).
   • std::forward<int>(arg) 会返回 int&& (右值).
   • process 接收到右值.

代码对比演示

#include <iostream>
#include <utility> // for std::move, std::forward

// 目标函数
void run(int& x)  { std::cout << "Lvalue ref" << std::endl; }
void run(int&& x) { std::cout << "Rvalue ref" << std::endl; }

// 1. 使用 std::move (鲁莽的中介)
template <typename T>
void bad_wrapper(T&& arg) {
    run(std::move(arg)); // 永远转为右值
}

// 2. 不做处理 (懒惰的中介)
template <typename T>
void lazy_wrapper(T&& arg) {
    run(arg); // 永远作为左值 (因为 arg 有名字)
}

// 3. 使用 std::forward (完美的中介)
template <typename T>
void perfect_wrapper(T&& arg) {
    run(std::forward<T>(arg)); // 还原原始属性
}

int main() {
    int a = 10;

    std::cout << "--- Bad Wrapper (std::move) ---" << std::endl;
    bad_wrapper(a); // 输出: Rvalue ref (危险！a 被意外移动了)
    bad_wrapper(10); // 输出: Rvalue ref (正确)

    std::cout << "\n--- Lazy Wrapper (Nothing) ---" << std::endl;
    lazy_wrapper(a); // 输出: Lvalue ref (正确)
    lazy_wrapper(10); // 输出: Lvalue ref (错误！本该移动却没移动)

    std::cout << "\n--- Perfect Wrapper (std::forward) ---" << std::endl;
    perfect_wrapper(a); // 输出: Lvalue ref (完美)
    perfect_wrapper(10); // 输出: Rvalue ref (完美)
}

二者各自的使用场所

这是区分它们的最佳记忆法:

• std::move: 用于 具体类型 的对象 (Concrete Types) .
  • 当你明确知道“这个变量以后我不用了，我要把它移走”时使用.
  • 常见场景: push_back(std::move(obj)), return std::move(res) (针对参数).
  • 意义: *我要处理掉它. *
• std::forward: 用于 模板类型 的 万能引用 (T&&).
  • 当你是一个“中间商”，不仅要传递数据，还要保留数据的“左/右值属性”给下游函数时使用.
  • 常见场景: emplace_back, make_unique, 函数包装器.
  • 意义: *我只是帮人传个话，原话照搬. *

正如其名, TTP 允许我们将“模板”本身作为参数传递给另一个模板. 这听起来可能有些抽象, 但它是实现高级抽象和“策略基设计 (Policy-Based Design)”的核心机制.

本文将详细探讨模板模板参数的定义, 用途, 语法, 并通过实例分析其在现代 C++ 库 (如 nlohmann/json) 中的关键作用.

1. 什么是模板模板参数?

要理解 TTP, 我们首先要将其与最常见的“类型参数”进行对比.

• 类型参数 (typename T)
  • 含义: “请给我一个类型”.
  • 传递: 你传递一个具体的类型, 如 int, std::string 或 MyClass.
  • 示例: std::vector<int>, 这里 int 是 T.
• 模板模板参数 (template<...> class C)
  • 含义: “请给我一个模板”.
  • 传递: 你传递一个模板本身, 如 std::vector, std::list 或 std::map.
  • 示例: MyContainer<int, std::vector>, 这里 std::vector 是 C.

核心类比: 如果 typename T 像是函数的一个值参数 (void func(int x)), 你传递的是一个具体的值 (如 5) ； 那么 TTP 就像是一个高阶函数参数 (void high_func(void (*f)(int))), 你传递的是一个函数 (或“行为”) 本身.

2. 为什么需要 TTP? 核心用途: 策略基设计

TTP 的主要目的不是为了处理“什么”数据 (typename T 已经做到了) , 而是为了定义“如何”组织和管理数据. 其最重要和最广泛的应用场景是策略基设计 (Policy-Based Design).

想象一下, 你正在设计一个类, 这个类内部需要一个容器来存储数据.

没有 TTP 的设计 (硬编码) :

template<typename T>
class DataManager {
private:
    std::vector<T> m_data; // 容器类型被写死
};

这个设计的问题在于其缺乏灵活性. 如果用户在特定场景下发现 std::list 或 std::deque 的性能远超 std::vector, 他们无法更改 DataManager 的内部实现.

使用 TTP 的设计 (策略注入) :

// 我们声明 TTP, 并指定它的“签名”
// 这个签名要求 'Container' 模板至少能接受一个类型参数
template<
    typename T,
    template<typename Element, typename...> class Container
>
class FlexibleDataManager {
private:
    // 我们使用 TTP 来“构造”我们的成员变量
    Container<T> m_data;
};

// --- 用户的使用 ---

// 1. 使用 std::vector 策略
FlexibleDataManager<int, std::vector> manager_vec;

// 2. 使用 std::list 策略
FlexibleDataManager<int, std::list> manager_list;

通过 TTP, 我们允许用户在编译时“注入”他们想要的容器策略, 从而在不修改 FlexibleDataManager 源码的情况下, 完全改变其内部行为和性能特征.

3. 语法与使用详解

TTP 的语法是它最令人困惑的部分, 但其本质是描述签名.

3.1 声明 (Declaration)

template <
    // 模板模板参数 (TTP)
    template<typename U> class Container,

    // 常规类型参数
    typename T
>
class MyClass {
    // ...
    // 使用 TTP 来实例化一个成员
    Container<T> m_member;
};

• template<typename U> class Container: 这是 TTP 的完整声明.
  • template<typename U>: 这部分被称为 TTP 的签名. 它声明了 Container 是一个模板, 并且这个模板期望接受一个类型参数 (我们在这里叫它 U, 名字不重要) .
  • class Container: 这是 TTP 的参数名, 就像 T 一样.

3.2 实例化 (Instantiation)

实例化时, 你必须传递一个模板名, 而不是一个完整的类型:

// 正确: 传递模板名 'std::vector'
MyClass<std::vector, int> good;

// 错误: 传递了完整的类型 'std::vector<int>'
// MyClass<std::vector<int>, int> bad; // 编译失败

编译器在 good 的实例化中看到 std::vector, 它会检查 std::vector 的声明是否与 template<typename U> 的签名匹配.

3.3 关键: 签名匹配 (Signature Matching)

TTP 的核心规则是: 你传入的模板, 必须能匹配你声明的 TTP 签名.

示例 1: 简单匹配

• TTP 声明: template<typename U> class C
• std::vector 声明 (简化): template<typename T, typename Alloc = std::allocator<T>> class vector
• 匹配结果: 成功.
• 原因: std::vector 至少需要一个模板参数 (T) , 这与 TTP 签名的 U 对应. 后续的 Allocator 参数因为有默认值, 所以是可选的, 编译器可以成功匹配.

示例 2: 可变参数匹配 (C++11 及以后)

在实践中, 我们希望 TTP 更加灵活, 能接受像 std::map 这样有多个参数的模板. 这时, typename... (可变参数模板) 就派上用场了.

// 声明一个 Storage 类, 它接受一个TTP, 该TTP
// 1. 至少要有一个类型参数 (Element)
// 2. 可以有任意多个后续参数 (Args...), 比如分配器
template <
    typename T,
    template<typename Element, typename... Args> class Container
>
class Storage {
public:
    void add(const T& item) {
        data.push_back(item);
    }
private:
    // 'Container' 被实例化为 'Container<T>'
    // (假设分配器等后续参数都有默认值)
    Container<T> data;
};

// --- 使用 ---
Storage<int, std::vector> vec_storage; // 匹配！
Storage<int, std::list>   list_storage; // 匹配！
Storage<int, std::deque>  deque_storage; // 匹配！

template<typename Element, typename... Args> class Container 是现代 C++ 中 TTP 最常用, 最灵活的“签名”形式.

4. 案例研究: nlohmann/json 的 basic_json

nlohmann/json 库中的 basic_json 是 TTP 策略基设计的绝佳范例.

template<
    template<typename U, typename V, typename... Args> class ObjectType = std::map,
    template<typename U, typename... Args> class ArrayType = std::vector,
    class StringType = std::string,
    class NumberIntegerType = std::int64_t,
    // ... 其他类型 ...
    template<typename U> class AllocatorType = std::allocator
>
class basic_json;

让我们分析其中两个 TTP:

1. ObjectType = std::map
   • TTP 声明: template<typename U, typename V, typename... Args> class ObjectType
   • 签名要求: 传入的模板必须能接受至少两个类型参数 (U 键类型, V 值类型) 以及任意多个后续参数 (...Args).
   • 默认值: std::map (其声明为 template<Key, T, Compare, Alloc>, 完美匹配) .
   • 灵活性: 用户可以轻松地将此模板参数替换为 std::unordered_map (其声明为 template<Key, T, Hash, Pred, Alloc>, 同样完美匹配) , 从而将 JSON 对象的内部存储从红黑树切换为哈希表, 以获取不同的性能权衡.
2. ArrayType = std::vector
   • TTP 声明: template<typename U, typename... Args> class ArrayType
   • 签名要求: 传入的模板必须能接受至少一个类型参数 (U 元素类型) 和任意多个后续参数.
   • 默认值: std::vector.
   • 灵活性: 用户可以将其替换为 std::deque.

我们通常使用的 nlohmann::json, 只不过是 basic_json 使用所有默认策略 (std::map, std::vector, std::string 等) 的一个类型别名 (type alias) 罢了.

总结

模板模板参数 (TTP) 是 C++ 元编程的一个高级工具. 它将 C++ 模板的抽象能力从“对类型进行参数化”提升到了“对模板 (即策略) 进行参数化”.

虽然其语法初看较为复杂, 但其核心价值在于实现了策略基设计, 允许库的作者设计出高度灵活, 可配置的组件, 同时将这些复杂性对默认用户隐藏起来. 理解 TTP 是深入理解现代 C++ 库设计 (如 nlohmann/json) 和高级模板编程的关键一步.

在 C++ 模板编程的领域中, 我们经常需要根据类型的不同属性 (Traits) 来选择性地启用或禁用特定的函数重载或类模板实现. 例如, 我们可能希望一个 destroy 函数对平凡可析构的类型 (如 int) 执行空操作, 而对非平凡可析构的类型 (如 std::string) 显式调用其析构函数.

实现这种编译期条件分支的核心机制之一, 就是 SFINAE, 而 std::enable_if 则是利用这一机制的标准库工具. 本文将从 std::enable_if 出发, 详细解析其工作原理及 SFINAE 机制, 并探讨其在不同场景下的应用.

核心机制: SFINAE (替换失败并非错误)

SFINAE 的全称是 “Substitution Failure Is Not An Error”, 即“替换失败并非错误”.

这是 C++ 模板重载解析的一条核心规则. 其含义是: 当编译器在为模板函数 (或类模板) 进行参数推导和替换时, 如果某个模板的签名 (包括返回类型, 参数类型等) 在替换过程中因为无效的类型操作而导致“失败” (例如, 试图访问一个不存在的成员类型 T::type) , 编译器不会立即报错.

相反, 编译器会默默地将这个导致替换失败的模板从重载候选集中移除, 然后继续尝试匹配其他候选函数. 如果最终只剩下一个有效的候选, 编译成功；如果剩下零个或多个, 编译器才会报告“找不到匹配函数”或“重载歧义”的错误.

SFINAE 是 C++ 模板元编程实现编译期自省 (Introspection) 和条件分派 (Dispatch) 的基石.

核心工具: std::enable_if

std::enable_if 是一个专门用于“故意”触发 SFINAE 的模板结构体, 其定义 (C++11) 大致如下:

// C++11, 位于 <type_traits>
// 基础模板
template<bool Condition, class T = void>
struct enable_if {};

// 当 Condition 为 true 时的特化版本
template<class T>
struct enable_if<true, T> {
  using type = T; // 定义了一个名为 'type' 的成员类型
};

其行为非常简单:

• 当 Condition 为 true 时: std::enable_if<true, T> 会有一个公开的成员类型 type (默认为 void) .
• 当 Condition 为 false 时: std::enable_if<false, T> 匹配的是基础模板, 该模板内部没有任何成员定义.

在 C++14 中, 我们有了一个更方便的别名助手 std::enable_if_t:

template<bool Condition, class T = void>
using enable_if_t = typename std::enable_if<Condition, T>::type;

关键技巧: 我们将 std::enable_if_t<Condition> (或 typename std::enable_if<Condition>::type) 放置在模板签名中.

• 如果 Condition 为 true, enable_if_t 会成功解析为一个类型 (如 void) , 函数签名有效.
• 如果 Condition 为 false, enable_if_t 会尝试访问一个不存在的 ::type, 导致模板替换失败. 此时 SFINAE 机制启动, 该模板被安全地从候选集中移除.

std::enable_if 的应用模式分析

std::enable_if 可以被巧妙地放置在函数签名的多个位置, 以达到 SFINAE 的效果.

模式一: 通过返回类型启用

这是最经典的应用方式. std::enable_if 的结果构成了函数返回类型的一部分.

#include <iostream>
#include <string>
#include <type_traits>

// #1: 仅当 T 是平凡默认构造时启用
template<class T>
typename std::enable_if<std::is_trivially_default_constructible<T>::value>::type 
construct(T*) {
    std::cout << "default constructing trivially default constructible T\n";
}

// #2: 仅当 T 不是平凡默认构造时启用
template<class T>
typename std::enable_if<!std::is_trivially_default_constructible<T>::value>::type 
construct(T* p) {
    std::cout << "default constructing non-trivially default constructible T\n";
    ::new(p) T; // 使用 placement new
}

解析:

当我们调用 construct(some_ptr) 时:

1. 若 T 为 int:
   • std::is_trivially_default_constructible<int>::value 为 true.
   • 重载 #1: std::enable_if<true>::type 变为 void. 函数签名为 void construct(int*). 候选有效.
   • 重载 #2: !std::enable_if<true>::type (即 false). 尝试访问 std::enable_if<false>::type 失败. SFINAE 触发, 此重载被忽略.
   • 结果: 调用 #1.
2. 若 T 为 std::string:
   • std::is_trivially_default_constructible<std::string>::value 为 false.
   • 重载 #1: std::enable_if<false>::type 失败. SFINAE 触发, 此重载被忽略.
   • 重载 #2: !std::enable_if<false>::type (即 true). 函数签名为 void construct(std::string*). 候选有效.
   • 结果: 调用 #2.

使用 std::enable_if_t (C++14) 可以使语法更简洁:

// 仅当 T 可以用 Args... 构造时启用
template<class T, class... Args>
std::enable_if_t<std::is_constructible<T, Args&&...>::value>
construct(T* p, Args&&... args) {
    std::cout << "constructing T with operation\n";
    ::new(p) T(static_cast<Args&&>(args)...);
}

模式二: 通过函数参数启用

SFINAE 也可以在函数参数类型中触发.

template<class T>
void destroy(
    T*, 
    typename std::enable_if<
        std::is_trivially_destructible<T>::value
    >::type* = 0)
{
    std::cout << "destroying trivially destructible T\n";
}

解析:

这里的技巧是添加一个额外的, 有默认值 (= 0 即 nullptr) 的函数参数. 该参数的类型依赖于 std::enable_if.

1. 若 T 为 int:
   • std::is_trivially_destructible<int> 为 true.
   • std::enable_if<true>::type 变为 void.
   • 第二个参数的类型解析为 void*.
   • 函数签名变为 void destroy(int*, void* = 0). 候选有效.
2. 若 T 为 std::string:
   • std::is_trivially_destructible<std::string> 为 false.
   • std::enable_if<false>::type 失败. SFINAE 触发, 此重载被忽略.

这种方式在 C++11 之前很流行, 但它会轻微地改变函数的签名 (增加了一个参数) .

模式三: 通过模板参数启用

这是一种更现代且更清晰的 SFINAE 技巧, 它不改变函数的参数列表. SFINAE 发生在模板参数列表中.

3a. 依赖非类型模板参数 (Non-type template parameter)

template<class T,
         typename std::enable_if<
             !std::is_trivially_destructible<T>{} &&
             (std::is_class<T>{} || std::is_union<T>{}),
             bool>::type = true> // 默认值为 true 的 bool 类型
void destroy(T* t)
{
    std::cout << "destroying non-trivially destructible T\n";
    t->~T();
}

解析:

我们添加了一个匿名的非类型模板参数, 其类型由 std::enable_if<Condition, bool>::type 决定.

1. 若 T 为 std::string:
   • 条件为 true.
   • std::enable_if<true, bool>::type 解析为 bool.
   • 模板签名变为 template<class T, bool = true> void destroy(T*). 候选有效.
2. 若 T 为 int:
   • 条件为 false.
   • std::enable_if<false, bool>::type 失败. SFINAE 触发, 此重载被忽略.

3b. 依赖类型模板参数 (Type template parameter)

这是目前最受推荐的 SFINAE 模式 (在 C++20 Concepts 出现之前) .

template<class T,
	 typename = std::enable_if_t<std::is_array<T>::value>>
void destroy(T* t) // 注意: 函数签名是干净的 void(T*)
{
    // ... 针对数组的实现 ...
    std::cout << "destroying array\n";
}

解析:

我们添加了一个匿名的类型模板参数, 其类型默认为 std::enable_if_t 的结果.

1. 若 T 为 int[10]:
   • std::is_array<int[10]>::value 为 true.
   • std::enable_if_t<true> 解析为 void.
   • 模板签名变为 template<class T, typename = void> void destroy(T*). 候选有效.
2. 若 T 为 int:
   • std::is_array<int>::value 为 false.
   • std::enable_if_t<false> 失败. SFINAE 触发, 此重载被忽略.

深入辨析: SFINAE 偏特化 vs. 显式特化

std::enable_if 不仅用于函数, 还常用于有条件地启用类模板偏特化. 这引出了一个重要的问题: 它和显式 (全) 特化有何区别？

我们来对比以下两种写法:

写法 1: enable_if 偏特化 (基于规则)

// primary template (主模板)
// 注意: 有两个模板参数
template<class T, class Enable = void>
class A {}; 

// partial specialization (偏特化)
template<class T>
class A<T, typename std::enable_if<std::is_floating_point<T>::value>::type>
{
    // ... 这个版本只为浮点数存在
};

• 机制: 这是偏特化 (Partial Specialization). 我们没有固定 T, 而是通过 SFINAE 让第二个参数 Enable 在 T 是浮点数时解析为 void, 从而匹配这个特化版本.
• 泛化能力: 高. 这是一个基于规则的实现. 它会自动匹配所有符合 std::is_floating_point 规则的类型 (float, double, long double) .
• 解析 A<double>: std::enable_if<true>::type 为 void. 特化版本匹配 A<double, void>, 优于主模板, 被选中.
• 解析 A<int>: std::enable_if<false>::type 失败. SFINAE 触发, 特化版本被忽略. 主模板 A<int, void> 被选中.

写法 2: 显式特化 (基于列表)

// primary template (主模板)
// 注意: 只有一个模板参数
template<class T>
class A {}; 

// explicit (full) specialization (显式特化)
template<>
class A<double>
{
    // ... 只为 double 的实现
};

// 必须为 float 也提供一个
template<>
class A<float>
{
    // ... 只为 float 的实现
};

• 机制: 这是显式特化 (Explicit/Full Specialization). template<> 表明我们为所有模板参数提供了具体类型.
• 泛化能力: 低. 这是一个基于列表的实现. 你必须为你关心的每一个具体类型编写一个特化版本.
• 解析 A<double>: 精确匹配 A<double> 特化版本.
• 解析 A<long double>: 匹配失败. 编译器找不到 A<long double> 的显式特化, 因此它会回头使用主模板 template<class T>, 实例化 A<long double>. 这很可能不是我们期望的行为.

对比总结

结论: 当您希望为一整类符合某个特征 (trait) 的类型提供统一实现时, 应使用 std::enable_if 进行偏特化. 当您只想为一两个特定类型提供完全定制的实现时, 才使用显式特化.

现代 C++ 的演进: 超越 SFINAE

虽然 SFINAE 和 std::enable_if 功能强大, 但它们语法晦涩, 且产生的错误信息往往令人难以理解. 现代 C++ 提供了更清晰的替代方案.

C++17: if constexpr

if constexpr 允许在函数体内部进行编译期分支. SFINAE 作用于函数签名 (选择哪个函数) , 而 if constexpr 作用于函数内部 (执行哪段代码) .

// 替代模式二和三中的 destroy
template<class T>
void destroy(T* t)
{
    if constexpr (std::is_trivially_destructible_v<T>) {
        // C++17 的 _v 助手, 等价于 ::value
        std::cout << "destroying trivially destructible T\n";
        // (此分支为 true 时, else 分支根本不会被编译)
    } else {
        std::cout << "destroying non-trivially destructible T\n";
        t->~T();
    }
}

if constexpr 极大简化了在函数内部根据类型特性执行不同代码逻辑的场景, 不再需要复杂的重载集.

C++20: Concepts (概念)

Concepts 是对 SFINAE 机制的直接替代, 旨在从语言层面解决模板约束问题. 它提供了清晰, 易读的语法, 并能产生高质量的错误信息.

// 替代模式一的 construct
#include <concepts> // C++20

template<class T>
requires std::is_trivially_default_constructible_v<T>
void construct(T*) {
    std::cout << "default constructing trivially default constructible T\n";
}

template<class T>
requires (!std::is_trivially_default_constructible_v<T>)
void construct(T* p) {
    std::cout << "default constructing non-trivially default constructible T\n";
    ::new(p) T;
}

requires 关键字清晰地表达了“此模板仅在满足…条件时才被启用”的意图, 这正是 std::enable_if 想要实现的目标, 但语法可读性提高了几个数量级.

总结

SFINAE 是 C++ 模板系统中一个精巧的 (尽管有些晦涩) 规则, 它允许模板在重载解析期间根据类型属性安全地“退出”候选集. std::enable_if 是标准库提供的, 用于利用 SFINAE 规则的“触发器”.

通过在返回类型, 函数参数或模板参数中巧妙地使用 std::enable_if, 我们可以在编译期实现高度灵活的类型分派. 尽管 C++17 的 if constexpr 和 C++20 的 Concepts 提供了更优越的解决方案, 但理解 SFINAE 及其应用, 对于深入掌握 C++ 模板元编程, 阅读遗留代码以及理解现代 C++ 特性背后的演进动机, 仍然至关重要.

本文将分为两部分. 第一部分详细介绍 ... 的核心语法和使用模式; 第二部分将深入分析编译器是如何处理 ... 的, 探讨其背后的底层实现机制.

第一部分: ... 的使用方法

... 在C++模板中有两种截然不同的角色: 声明参数包和展开参数包.

1. 核心语法: 声明参数包 (Parameter Pack)

参数包是一个可以容纳零个或多个模板参数的“容器”.

模板类型参数包 (Template Type Parameter Pack)

在模板参数列表中, typename... 或 class... 声明了一个“模板类型参数包”.

// "Args" 是一个模板类型参数包, 代表 0 或多个类型. 
template<typename... Args> 
class MyClass {
    // ...
};

// 用法示例:
MyClass<> obj1;                // Args = [] (空包)
MyClass<int> obj2;             // Args = [int]
MyClass<int, double, bool> obj3; // Args = [int, double, bool]

函数参数包 (Function Parameter Pack)

在函数参数列表中, Args... args 声明了一个“函数参数包”, 它由对应类型包Args中的所有类型构成.

// "args" 是一个函数参数包, 代表 0 或多个函数参数. 
template<typename... Args>
void myFunction(Args... args) {
    // ...
}

myFunction();             // args = []
myFunction(1);            // args = [1]
myFunction(1, "hello"); // args = [1, "hello"]

2. 关键操作: 展开参数包 (Pack Expansion)

声明参数包后, 我们不能像遍历数组一样在运行时去迭代它. 参数包必须在编译期被“展开”. 展开的语法是在包名 (如 args) 或模式 (如 std::forward<Args>(args)) 后跟一个 ....

以下是几种最核心的展开模式.

方法一: 递归模板函数 (C++11 经典模式)

这是理解参数包展开的基础. 我们定义一个递归的模板函数, 一次处理包中的一个参数, 然后用剩余的参数递归调用自身.

• 递归步骤: 定义一个模板, 接受至少一个参数 T first 和一个参数包 Args... rest.
• 基本情况 (Base Case): 定义一个同名的, 不接受参数 (或参数包为空) 的函数重载, 用于终止递归.

示例: 实现一个泛型的 print 函数

#include <iostream>

// 1. 基本情况 (Base Case): 参数包为空时调用
void print() {
    std::cout << std::endl;
}

// 2. 递归步骤: 
//    T 匹配第一个参数, Args... 匹配所有剩余参数
template<typename T, typename... Args>
void print(T first, Args... rest) {
    std::cout << first << " "; // 处理第一个参数
    
    // 展开 "rest" 包并递归调用
    // 如果 rest = [1, "hi"], 这里会被展开为 print(1, "hi");
    print(rest...);           
}

int main() {
    print("Value:", 10, 3.14);
    // 输出: Value: 10 3.14 
}

方法二: pattern... 展开与完美转发 (C++11)

... 的一个极其重要的用途是完美转发 (Perfect Forwarding). 它允许我们将参数以其原始的值类别 (左值或右值) 转发给另一个函数, 这在工厂函数和构造函数包装器中至关重要.

语法是 pattern..., 其中 pattern 是一个包含参数包的表达式.

示例: 实现一个简化的 make_unique

#include <memory>
#include <utility> // for std::forward

template<typename T, typename... Args>
std::unique_ptr<T> make_my_unique(Args&&... args) {
    // 1. Args&&... args: 
    //    这里的 "Args" 是模板参数包, "args" 是函数参数包. 
    //    "Args&&" 是通用引用(Universal Reference)的包. 

    // 2. 关键的展开: 
    //    模式(pattern)是: std::forward<Args>(args)
    //    "..." 指示编译器将此模式应用到 "args" 包中的每一个元素, 
    //    并用逗号分隔. 
    //
    //    假设调用 make_my_unique<MyType>(1, "hi")
    //    "Args" 被推导为 [int, const char*]
    //    "args" 包包含 [1, "hi"]
    //    展开结果为: 
    //        std::forward<int>(arg1), std::forward<const char*>(arg2)
    //
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

这种 pattern... 展开也常用于初始化列表, 例如 std::array<int, sizeof...(Args)> { (args * 2)... };.

方法三: 折叠表达式 (C++17)

C++17 引入了折叠表达式 (Fold Expressions), 极大地简化了对参数包应用二元运算符的操作, 使递归不再是必需的.

它有四种形式, 最常用的是一元右折叠 (Unary Right Fold) (pack ... op).

示例 1: 计算所有参数的总和

template<typename... Args>
auto sum(Args... args) {
    // (args + ...): 一元右折叠
    // 如果 args = [1, 2, 3, 4]
    // 展开为: (1 + (2 + (3 + 4)))
    return (args + ...);
}

int total = sum(1, 2, 3, 4, 5); // 15

*注意: 对于空包 sum(), + 运算符会编译失败. C++17 为此提供了 (pack op ... op initial_value) 的形式, 或在 C++20 中使用 requires 约束. *

示例 2: 使用逗号运算符实现 print (C++17)

我们可以利用逗号运算符的从左到右求值的特性, 在一行代码内实现 print.

template<typename... Args>
void print_modern(Args... args) {
    // "模式" 是 (std::cout << args << " ")
    // "运算符(op)" 是 , (逗号)
    // 展开为:
    // ((std::cout << arg1 << " "), ((std::cout << arg2 << " "), ...))
    ((std::cout << args << " "), ...);
    std::cout << std::endl;
}

3. 辅助工具: sizeof...

要获取参数包中的元素个数, 可以使用 sizeof... 运算符.

template<typename... Args>
size_t count(Args... args) {
    return sizeof...(Args); // 推荐
    // return sizeof...(args); // 也可以
}

size_t c = count(1, 2.5, "three"); // c == 3

第二部分: ... 的底层原理

... 并不是一个运行时机制. 它的所有魔力都发生在编译期, 属于模板元编程 (Template Metaprogramming, TMP) 的范畴. 编译器会根据 ... 指令生成特定的代码.

以下是 ... 的几种核心工作机制.

机制一: 递归模板实例化 (C++11/14)

这是C++11中最核心的机制, 它在编译期模拟了递归. 我们以 print 函数为例, 分析编译器的“视角”.

当编译器遇到 print("Hello", 1, 3.14); 调用时:

1. 第一次实例化:

   • 编译器匹配到 print<T, typename... Args>.

   • 推导 T = const char*, Args = [int, double].

   • 编译器生成一个新函数 (我们称之为 print_1) :

     // 编译器内部生成的函数 #1
     void print_1(const char* first, int rest_arg1, double rest_arg2) {
         std::cout << first << " ";
         print(rest_arg1, rest_arg2); // 展开 "rest..." 
     }
     

2. 第二次实例化:

   • 在编译 print_1 时, 编译器遇到了新调用 print(1, 3.14);.

   • 它再次匹配 print<T, typename... Args>.

   • 推导 T = int, Args = [double].

   • 编译器生成第二个函数 (print_2) :

     // 编译器内部生成的函数 #2
     void print_2(int first, double rest_arg1) {
         std::cout << first << " ";
         print(rest_arg1); // 展开 "rest..."
     }
     

3. 第三次实例化:

   • 在编译 print_2 时, 编译器遇到了 print(3.14);.

   • 推导 T = double, Args = [] (空包).

   • 编译器生成第三个函数 (print_3) :

     // 编译器内部生成的函数 #3
     void print_3(double first) {
         std::cout << first << " ";
         print(); // 展开 "rest..." (空包)
     }
     

4. 递归终止:

   • 在编译 print_3 时, 编译器遇到了 print();.
   • 此时, 模板函数不再是最佳匹配 (因为它至少需要一个 T) .
   • 编译器选择 void print() 这个非模板的基本情况 (Base Case).
   • 递归实例化结束.

原理总结: ... 驱动了编译器的递归模板实例化过程. 最终的可执行文件中并没有“循环”, 而是包含了一系列被静态链接起来的, 特化 (或实例化) 的函数调用链.

机制二: pattern... 原地展开

当编译器遇到 pattern... 语法时 (如 std::forward<Args>(args)...) , 它会扮演一个“代码复读机”的角色.

它在抽象语法树 (AST) 中识别出这个模式, 然后将其“水平地”展开, 为参数包中的每一个元素生成一份代码, 并用逗号 , 分隔.

// 模板代码:
new T(std::forward<Args>(args)...);

// 假设 Args = [int, double]
// 编译器在 AST 中将其重写(rewrite)为:
new T(std::forward<int>(arg1), std::forward<double>(arg2));

这个机制常用于函数调用, 初始化列表和基类列表.

机制三: 折叠表达式的AST转换 (C++17)

C++17的折叠表达式是一种更高级的机制. 它让编译器不再需要通过递归实例化来“折叠”参数包, 而是直接在AST上进行树状结构转换.

// 模板代码:
return (args + ...); // 一元右折叠

// 假设 args = [1, 2, 3]
// 编译器在 AST 中直接将其重写为: 
return (1 + (2 + 3));

这比递归实例化更简洁, 编译速度可能更快, 并且意图更明显. print_modern 中对逗号运算符的折叠也是同理.

机制四: 递归继承与数据结构

... 不仅用于函数, 还用于类. std::tuple 是如何存储任意数量和类型的成员的？答案是递归继承.

一个简化的 Tuple 实现如下:

// 基本情况: 空 Tuple
template <typename... Types>
class Tuple;

template <>
class Tuple<> {}; // 0个元素的 Tuple

// 递归步骤
template <typename Head, typename... Tail>
class Tuple<Head, Tail...> : private Tuple<Tail...> // 继承"尾巴"
{
public:
    // ... 构造函数 ...
    Head m_head; // 存储包中的第一个元素
};

当编译器看到 Tuple<int, double, char> 时, 它会生成一个类继承链:

1. Tuple<int, double, char>
   • 有一个成员 int m_head
   • 继承自 Tuple<double, char>
2. Tuple<double, char>
   • 有一个成员 double m_head
   • 继承自 Tuple<char>
3. Tuple<char>
   • 有一个成员 char m_head
   • 继承自 Tuple<> (空基类)

原理总结: ... 在类模板中驱动了编译期的递归继承. 编译器为你生成了一系列嵌套的类定义, 巧妙地将一个“包含N个成员的类”在内存中表示为 N 个“各自包含1个成员的类”的继承链. 空基类优化 (Empty Base Class Optimization, EBCO) 会确保 Tuple<> 基类不占用任何空间.

结论

C++ 中的 ... 是一个强大的模板元编程工具. 它为编译器提供了指令, 使其能够在编译时通过递归实例化, 原地展开, AST转换和递归继承等机制来自动生成高度特化和泛型的代码. 理解这些底层原理, 是精通现代C++泛型编程的关键.

在 <charconv> 出现之前, C++ 开发者通常有以下几种选择, 但它们各有缺点:

1. C 风格 (stdio): sprintf, sscanf, atoi, atof 等.
   • 缺点: 类型不安全, 容易导致缓冲区溢出 (尤其是 sprintf) , 并且 sscanf 的性能不佳.
2. C++ 字符串流 (sstream): std::stringstream.
   • 缺点: 性能开销大, 涉及动态内存分配, 并且受本地化 (locale) 影响 (例如, 某些地区用 , 作小数点) .
3. C++11 (string): std::stoi, std::stod, std::to_string 等.
   • 缺点:
     • 它们会抛出异常 ( std::invalid_argument, std::out_of_range ), 这在性能敏感的代码中 (如游戏循环, 高频交易) 可能是不可接受的开销.
     • std::to_string 内部可能进行内存分配.
     • 它们仍然受本地化 (locale) 影响.

<charconv> 旨在彻底解决以上所有痛点.

<charconv> 的核心特性

1. 高性能 (High Performance):

   它的实现被高度优化, 通常是 C++ 中最快的数字-字符串转换方式, 甚至快于 C 风格的 itoa (非标准) 或 sprintf.

2. 无内存分配 (Non-allocating):

   所有操作都在用户提供的固定大小的字符缓冲区上进行. 它不会在堆上分配任何内存.

3. 无异常 (Non-throwing):

   它通过返回一个包含错误码的 struct 来报告成功或失败, 而不是抛出异常. 这使得错误处理的开销极低.

4. 区域设置无关 (Locale-independent):

   它始终使用 “C” locale 规则 (例如, 小数点总是 ‘.’) . 这对于配置文件, JSON, XML, 网络协议等需要固定格式的数据序列化和反序列化至关重要.

两个核心函数

<charconv> 只提供了两个核心函数模板 (及其重载) :

1. std::to_chars: 将数值转换为字符串.
2. std::from_chars: 将字符串转换为数值.

它们都通过返回一个 struct 来报告操作结果.

1. std::to_chars (数值 -> 字符串)

它尝试将一个数值格式化后写入你提供的字符缓冲区 [first, last) 中.

函数签名 (整数)

std::to_chars_result std::to_chars(
    char* first,          // 缓冲区的起始指针
    char* last,           // 缓冲区的末尾指针 (one-past-the-end)
    T value,              // 要转换的数值
    int base = 10         // 进制 (支持 2 到 36)
);

• T: 可以是 int, long, unsigned int, unsigned long long 等各种整数类型.

返回值: std::to_chars_result

这是一个 struct, 定义大致如下:

struct std::to_chars_result {
    char* ptr;          // 指向写入的最后一个字符的 *下一个* 位置
    std::errc ec;       // 错误码
};

• 如果 ec 是 std::errc() (即默认构造, 表示成功), 则 [first, ptr) 范围内就是转换后的字符串.
• 如果 ec 是 std::errc::value_too_large, 表示你提供的缓冲区 [first, last) 不够大, 无法容纳转换后的字符串.

2. std::from_chars (字符串 -> 数值)

它尝试从字符缓冲区 [first, last) 中解析一个数值.

函数签名 (整数)

std::from_chars_result std::from_chars(
    const char* first,    // 要解析的字符串的起始指针
    const char* last,     // 要解析的字符串的末尾指针
    T& value,             // [out] 用于接收解析结果的变量
    int base = 10         // 进制 (支持 2 到 36)
);

• T: 必须是一个整数类型.

返回值: std::from_chars_result

定义大致如下:

struct std::from_chars_result {
    const char* ptr;    // 指向 *未被* 解析的第一个字符
    std::errc ec;       // 错误码
};

• 如果 ec 是 std::errc() (成功):
  • value 中存储了T-sl” >解析到的值.
  • ptr 指向第一个无法解析的字符. 例如, 解析 “12345abc”, ptr 会指向 ‘a’.
• 如果 ec 是 std::errc::invalid_argument:
  • 表示在 [first, last) 范围内找不到任何有效的数字模式.
• 如果 ec 是 std::errc::result_out_of_range:
  • 表示解析到的数字超出了类型 T 所能表示的范围 (上溢或下溢) .

浮点数支持

std::to_chars 和 std::from_chars 同样重载了 float, double 和 long double.

浮点数版本的函数签名略有不同, 它们接受一个 std::chars_format 枚举来指定格式 (如科学计数法, 固定小数点等) , 并且 (目前) 不支持指定 base (总是 10 进制) .

// 浮点数 to_chars 示例
std::to_chars_result std::to_chars(
    char* first, char* last,
    double value,
    std::chars_format fmt = std::chars_format::general,
    int precision = -1 // 默认精度
);

// 浮点数 from_chars 示例
std::from_chars_result std::from_chars(
    const char* first, const char* last,
    double& value,
    std::chars_format fmt = std::chars_format::general
);

std::chars_format 的值包括:

• std::chars_format::general (默认, 结合了 fixed 和 scientific)
• std::chars_format::fixed (定点表示)
• std::chars_format::scientific (科学计数法)
• std::chars_format::hex (十六进制浮点数)

完整示例代码

下面是一个结合使用 C++17 的 std::string_view 和结构化绑定 (Structured Bindings) 的现代 C++ 示例:

#include <iostream>
#include <charconv>     // 核心头文件
#include <string>
#include <string_view>
#include <system_error> // std::errc
#include <array>        // std::array

// 辅助函数: 将 std::errc 转换为字符串以便打印
std::string error_to_string(std::errc ec) {
    if (ec == std::errc()) {
        return "Success";
    }
    return std::make_error_code(ec).message();
}

int main() {
    // ------------------------------------------------
    // 示例 1: std::to_chars (int -> string)
    // ------------------------------------------------
    std::cout << "--- std::to_chars ---" << std::endl;
    int my_value = 1989;
    
    // 必须提供一个缓冲区. std::array 是一个很好的选择. 
    // 整数最多约20位 (64位) + 负号, 30 足够了. 
    std::array<char, 30> buffer; 

    // 使用 C++17 结构化绑定
    if (auto [ptr, ec] = std::to_chars(buffer.data(), buffer.data() + buffer.size(), my_value, 10);
        ec == std::errc()) 
    {
        // 成功！
        // ptr 指向写入的末尾
        // 使用 string_view 来安全地封装结果, 无需拷贝
        std::string_view sv(buffer.data(), ptr - buffer.data());
        
        std::cout << "Value: " << my_value << std::endl;
        std::cout << "String: '" << sv << "'" << std::endl;
        std::cout << "Length: " << sv.length() << std::endl;
    } else {
        // 缓冲区太小 (value_too_large) 或其他错误
        std::cout << "Conversion failed: " << error_to_string(ec) << std::endl;
    }

    // ------------------------------------------------
    // 示例 2: std::from_chars (string -> int)
    // ------------------------------------------------
    std::cout << "\n--- std::from_chars ---" << std::endl;
    std::string_view str_valid = "42 Hello";
    std::string_view str_invalid = "NotANumber";
    std::string_view str_overflow = "99999999999999999999999999999";
    int result = 0;

    // 尝试解析 "42 Hello"
    if (auto [ptr, ec] = std::from_chars(str_valid.data(), str_valid.data() + str_valid.size(), result, 10);
        ec == std::errc())
    {
        std::cout << "Parsed '" << str_valid << "' -> " << result << std::endl;
        std::cout << "Remaining string starts at: '" << ptr << "'" << std::endl; // 应该指向 ' Hello'
    } else {
        std::cout << "Failed to parse '" << str_valid << "': " << error_to_string(ec) << std::endl;
    }

    // 尝试解析 "NotANumber"
    if (auto [ptr, ec] = std::from_chars(str_invalid.data(), str_invalid.data() + str_invalid.size(), result, 10);
        ec == std::errc())
    {
        std::cout << "Parsed '" << str_invalid << "' -> " << result << std::endl;
    } else {
        // 这将失败, ec == std::errc::invalid_argument
        std::cout << "Failed to parse '" << str_invalid << "': " << error_to_string(ec) << std::endl;
    }

    // 尝试解析溢出的数字
    if (auto [ptr, ec] = std::from_chars(str_overflow.data(), str_overflow.data() + str_overflow.size(), result, 10);
        ec == std::errc())
    {
        std::cout << "Parsed '" << str_overflow << "' -> " << result << std::endl;
    } else {
        // 这将失败, ec == std::errc::result_out_of_range
        std::cout << "Failed to parse '" << str_overflow << "': " << error_to_string(ec) << std::endl;
    }
    
    return 0;
}

输出如下:

--- std::to_chars ---
Value: 1989
String: '1989'
Length: 4

--- std::from_chars ---
Parsed '42 Hello' -> 42
Remaining string starts at: ' Hello'
Failed to parse 'NotANumber': Invalid argument
Failed to parse '99999999999999999999999999999': Result too large

总结

<charconv> 是 C++17 中一项革命性的补充. 当你需要进行高性能的数字和字符串转换时, 它应该是你的首选, 特别是在以下场景:

• 解析 JSON, XML 或自定义的配置文件.
• 网络编程中序列化/反序列化消息.
• 游戏引擎或实时模拟.
• 任何你希望避免异常和内存分配的底层库代码.

成员函数指针的使用

1. 问题的根源: 多重继承与this指针

要理解为何需要调整, 首先要看多重继承的内存布局. 假设有如下结构:

struct Base1 { int b1; };
struct Base2 { int b2; };
struct Derived : public Base1, public Base2 { int d; };

一个 Derived 对象的内存布局通常是 [ Base1 subobject | Base2 subobject | Derived members ]. 这意味着, 一个 Derived 对象指针 d_ptr 在数值上与其 Base1 子对象的指针相等, 但与 Base2 子对象的指针不相等.

Derived* d_ptr = new Derived();
Base1* b1_ptr = d_ptr; // 地址值相同
Base2* b2_ptr = d_ptr; // 地址值不同！编译器会自动加上一个偏移量

因此, 如果一个成员函数指针指向 Base2 的成员, 并通过一个 Derived 对象来调用它, 那么传递给该函数的 this 指针必须被精确地调整到 Base2 子对象的起始地址.

2. 成员函数指针的用法 (Usage)

成员函数指针是一种独特的C++类型, 用于存储一个非静态成员函数的“调用信息”. 其使用遵循三个步骤:

1. 声明 (Declaration) 其类型包含函数的返回类型、所属类名和参数列表. ReturnType (ClassName::*PointerName)(ArgTypes);

   // 声明一个指针 p_func, 它可以指向 MyClass 中任何“返回void, 无参数”的成员函数
   void (MyClass::*p_func)();
   

2. 赋值 (Assignment) 必须使用取地址运算符 &, 并明确指定类作用域. PointerName = &ClassName::FunctionName;

   auto p_func = &MyClass::my_method;
   // 展开后的完整类型声明如下:
   // void (MyClass::*p_func) = &MyClass::my_method;
   

3. 调用 (Invocation) 必须通过 .* (用于对象或引用) 或 ->* (用于指针) 运算符, 将其与一个类的实例“绑定”后才能调用.

   MyClass obj;
   MyClass* p_obj = &obj;
      
   (obj.*p_func)();      // 通过对象调用
   (p_obj->*p_func)();   // 通过对象指针调用
   

现代C++ (C++11及以后) 更倾向于使用std::function和 Lambda 表达式而非裸露的成员函数指针作为通用的回调机制.

成员函数指针的原理

3. 实际的 {ptr, adj} 结构

在遵循 Itanium C++ ABI 的64位系统 (如 g++ on Linux) 上, 一个成员函数指针的内存表示为一个16字节的结构体, 我们称其为 {ptr, adj} 组合.

struct MemberFunctionPointer {
    // 函数信息: 对于非虚函数是地址, 对于虚函数是vtable偏移
    void* ptr;
    // this指针调整量 (字节偏移) 
    std::ptrdiff_t adj; 
};

• ptr: 存储函数的核心信息.
• adj: 存储一个偏移量, 用于在某些复杂的继承场景下调整this指针.

具体来讲,

• ptr (void*, 8字节): ptr 字段的内容取决于所指向的函数类型:
  1. 指向非虚函数 (Non-Virtual Function)
     • ptr 存储该函数在代码段中的直接内存地址.
     • 根据ABI假设, 这个地址的最低位永远是0.
  2. 指向虚函数 (Virtual Function)
     • ptr 存储一个编码后的值: 1 + vtable_offset.
     • 最低位为1: 这是虚函数的“身份标志”.
     • 值右移一位 (ptr >> 1): 得到的是该函数在其v-table中的字节偏移量. 例如, 如果 print_v 是虚析构函数后的第一个虚函数, 其vtable偏移为8, 则 ptr 的值会是 1 + 8 = 9 (二进制 ...1001).
  3. 指向 nullptr
     • ptr 字段的值为 0 (NULL).
• adj (ptrdiff_t, 8字节):
  • 产生于成员函数指针赋值时, 赋值操作 pfunc_derived = &base::func 本质是一次从“指向基类成员的指针”到“指向派生类成员的指针”的类型转换.
  • 在进行这个转换时, 编译器会预先计算出基类子对象 (base) 在派生类 (derived) 中的内存偏移量, 即adj. 如果该基类是第一个基类, 则偏移量adj为0.
  • 但在可观测结果相同的前提下, 实际情况取决于编译器实现, 因为C++标准中未给出具体实现, 以上说法均根据 Itanium C++ ABI 与实验观测结果.

4. .* 运算符的统一调用模型

当编译器遇到 (object.*pointer)() 这样的表达式时, 它会遵循一个统一的两步模型来确保this指针的正确性.

第一步: 编译期类型对齐 (Compile-Time Type Alignment)

编译器首先比较 object 的类型和 pointer 所属的类类型.

如果 object 的类型是 pointer 所属类的派生类, 编译器会在编译期执行一次向上转型 (Upcasting). 这会生成在运行时调整地址的指令, 将 object 的地址转换为其基类子对象的地址.

• 示例: (derived_obj.*base_class_pointer)()
• 动作: 编译器生成代码, 将 &derived_obj 的地址调整为 derived_obj 内部 Base 子对象的地址.

如果类型匹配, 则此步骤不产生地址变化.

第二步: adj 偏移应用 (Runtime adj Adjustment)

在第一步 (如果需要的话) 完成地址调整之后, 程序会读取成员函数指针内部的 adj 字段, 并将其加到第一步调整后的地址上.

final_this = result_from_step_1 + pointer.adj;

这一步解释了为何成员函数指针需要 adj 字段. 当一个“指向基类成员的指针”被赋值给一个“指向派生类成员的指针”变量时, adj 就会被编译器设置为一个非零值, 用以表示这两个类之间的内存偏移.

derived class:
+-------------------+
| |     base1     | | -> adj = 0
| +---------------+ |
| |     base2     | | -> adj = sizeof(base1)
| +---------------+ |
| | other members | |
+-------------------+

第一步类型对齐和第二步adj偏移对this指针调整的应用发生在.*运算符的调用时, 而adj的生成发生在成员函数指针的赋值时.

与普通函数指针的差异及问题

成员函数指针与普通函数指针在原理上完全不同, 不可混用.

核心答案是：几乎没有, 而且设计上就是为了避免有.

Git 的一个核心设计理念就是可移植性 (Portability). 一个 Git 仓库被设计成一个完全自包含的单元, 你可以把它复制到任何地方（另一台电脑、一个 U 盘、一个网络驱动器）, 它都能正常工作.

如果 .git 目录中硬编码了你本地的绝对路径（比如 C:\Users\MyUser\Projects\my-repo 或 /home/user/works/my-repo）, 那么一旦你移动了它, 或者把它发给同事, 仓库就会立刻“损坏”.

那么 .git 目录里到底存了什么呢?

• 对象 (objects): 包含了你所有的提交、文件内容和目录结构. 这些都是通过哈希值组织的, 与文件系统的路径无关.

• 引用 (refs): 指向各个分支和标签的指针（比如 refs/heads/main）.

• HEAD: 指向你当前所在的分支.

• config: 这是唯一一个可能包含“路径”信息的文件, 但它包含的是远程仓库的 URL 地址, 而不是你本地仓库的路径.

  [remote "origin"]
      url = https://github.com/your-username/your-repo.git
      fetch = +refs/heads/*:refs/remotes/origin/*
  

  这个 URL 指向的是 GitHub 服务器, 而不是你本地的 D: 盘或 /home 目录.

唯一的例外情况： 如果你自己编写了自定义的 Git 钩子 (Git Hooks)（位于 .git/hooks/ 目录下的脚本）, 并且在脚本中硬编码了绝对路径, 那么这些脚本里就会包含本地路径信息. 但这是用户自己的行为, 并非 Git 的默认机制.

2. 能否通过直接移动整个仓库文件夹的方式实现转移?

答案是：完全可以, 而且这正是推荐的做法.

基于上面的解释, 因为 Git 仓库是自包含的, 所以移动它的位置就和移动一个普通的文件夹一样简单和安全.

当你移动了整个项目文件夹（例如从 C:\projects 移动到 D:\my-work）, 包含了工作区文件和 .git 目录的所有相对关系都没有改变.

操作流程非常简单：

1. 关闭相关程序：确保没有正在使用该仓库的程序在运行（比如 VS Code、Sourcetree、终端等）, 以避免文件占用问题.
2. 移动文件夹：直接通过你的文件资源管理器（或命令行中的 mv 命令）剪切并粘贴整个项目文件夹到新的位置.
3. 在新位置继续工作：
   • 打开一个新的终端窗口.
   • cd 到新的目录路径下.
   • 运行 git status 或 git log.

你会发现, 所有 Git 命令都像以前一样正常工作. Git 会自动在当前目录及其父目录中寻找 .git 文件夹来确定自己所处的仓库, 这个机制与文件夹的绝对路径无关.

需要注意的潜在影响 (Git 本身之外)

虽然移动对 Git 仓库本身没有影响, 但可能会影响到你的工作环境：

• IDE / 编辑器: 像 VS Code、IntelliJ IDEA 或 Sourcetree 这样的工具, 它们的“最近打开的项目”列表里记录的是旧的绝对路径. 移动文件夹后, 你需要从新位置重新“打开项目”, 此后这个快捷方式就会更新.
• 终端的书签或历史记录: 如果你使用了终端书签或者依赖命令历史记录来进入项目目录, 你需要更新它们.
• 自定义脚本: 如果你有任何外部脚本（非 Git Hooks）依赖于项目的旧路径, 你需要手动更新这些脚本.

例如, 以下代码的输出可能不符合直觉:

#include <iostream>

void analyzeArray(int arr[10]) {
    // 试图在函数内获取大小
    std::cout << "函数内 sizeof(arr): " << sizeof(arr) << std::endl;
}

int main() {
    int my_array[10] = {0};
    // 在定义的作用域内获取大小
    std::cout << "函数外 sizeof(my_array): " << sizeof(my_array) << std::endl;
    
    analyzeArray(my_array);
    return 0;
}

在64位系统上, 典型的输出为:

函数外 sizeof(my_array): 40
函数内 sizeof(arr): 8

sizeof(my_array) 正确地返回了数组的总字节数（4字节/int * 10个元素 = 40字节）, 而 sizeof(arr) 返回的却是指针的大小. 这种现象被称为“数组退化” (Array Decay).

数组退化的原理

根据C++标准, 当数组作为函数参数按值传递时, 其类型会被自动调整 (adjusted) 为指向其首元素的指针类型.

因此, void analyzeArray(int arr[10]) 的函数签名在功能上与 void analyzeArray(int* arr) 完全等价. 方括号中的大小 10 会被编译器忽略, 函数实际接收的是一个 int* 指针.

这就是为什么在函数内部 sizeof(arr) 计算的是指针类型的大小, 而不是原始数组的大小. 这个特性源于C语言, 虽然在某些情况下有用, 但也导致了数组尺寸信息的丢失.

解决方案: 使用数组引用防止退化

要解决尺寸信息丢失的问题, 就必须阻止数组退化. 这可以通过将函数参数声明为数组的引用 (Reference to an Array) 来实现.

其语法如下:

T (&a)[N]

这个声明的含义是: a 是一个引用, 它引用的对象是一个大小为 N、元素类型为 T 的数组.

当以引用的方式传递数组时, 函数接收到的是对原始数组对象本身的绑定, 而不是一个指向其首元素的指针. 因此, 数组的完整类型 T[N] 得以保留, 编译器就能从中得知其尺寸.

通用实现: 结合模板在编译期获取大小

为了创建一个可以获取任何类型和大小的数组尺寸的通用函数, 可以将数组引用与函数模板相结合.

#include <cstddef> // for std::size_t

template<class T, std::size_t N>
constexpr std::size_t getArraySize(T (&a)[N]) noexcept
{
    return N;
}

该模板函数的工作机制如下:

1. 模板参数: 函数模板有两个参数: 类型参数 T 用于匹配数组的元素类型, 非类型模板参数 std::size_t N 用于匹配数组的大小.
2. 函数参数: T (&a)[N] 确保了只有真正的数组才能作为实参, 并且在传参时不发生退化.
3. 模板参数推导: 当一个具体数组被传入时, 编译器会进行参数推导. 例如, 对于一个 int numbers[10] 类型的数组, 编译器会将其类型 int[10] 与 T (&a)[N] 进行匹配, 从而成功推导出 T 为 int, N 为 10.
4. 编译期计算: 函数返回推导出的 N 值. constexpr 关键字确保了只要传入的数组大小是编译期已知的, 整个函数调用就会在编译时完成, 直接将结果（一个常量）嵌入到代码中, 没有任何运行时开销.

现代化C++实践: 使用 std::size

上述模板函数的实现是一种非常重要的C++编程模式. 自C++17起, 这个功能已被标准化, 并作为 std::size 函数提供在 <array> 和 <iterator> 头文件中.

在现代C++项目中, 推荐直接使用 std::size:

#include <iterator> // C++17 or <array> in C++20
#include <iostream>

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    std::cout << "使用 std::size 获取大小: " << std::size(numbers) << std::endl; // 输出 5
}

std::size 的底层实现原理与我们手动编写的 getArraySize 模板函数是相同的.

总结

• 数组退化: C++中, 按值传递的数组形参会被调整为指针, 导致尺寸信息丢失.
• 数组引用: 通过将形参声明为 T (&a)[N], 可以阻止数组退化, 保留完整的类型信息.
• 模板推导: 结合模板, 可以从不退化的数组类型中自动推导出其大小 N.
• std::size: C++17标准提供了 std::size 函数, 作为获取原生数组大小的标准、安全且高效的方式.

核心作用 (Purpose)

constexpr 的核心作用是将计算尽可能地从运行时 (runtime) 提前到编译时 (compile time). 这样做带来了四大好处:

1. 性能提升: 编译时完成的计算, 程序运行时无需再做, 直接使用结果, 从而提升了执行效率.
2. 编译期检查: 可以在编译阶段使用 static_assert 对计算结果进行验证, 将潜在的运行时错误转变为编译错误.
3. 常量保证: constexpr 变量是真正的编译期常量, 可以用于数组大小、模板参数等必须在编译时确定的场景.
4. 增强元编程: 使得在编译期间执行更复杂的算法成为可能.

主要用法 (Usage)

constexpr 可以修饰变量、函数和构造函数:

• constexpr 变量: 必须在声明时用一个“常量表达式”来初始化. 它天生就是 const 的.

• constexpr 函数: 是一种“两用函数”:

  • 当传入的参数都是编译期常量时, 它就在编译时执行.
  • 当传入的参数包含运行时变量时, 它就和普通函数一样在运行时执行.
  • 可以把 lambda 表达式声明为constexpr:

    auto infDist = [](int val) constexpr -> int {...}
    

• 与 const 的关键区别:

  • const 强调不变性 (Immutability): 变量初始化后值不能再改变, 但初始化可以在运行时进行.
  • constexpr 强调编译期可知性 (Compile-time Knowability): 变量的值必须在编译时就能确定.

规则（随 C++ 标准演进）

• C++11：非常严格。函数体内只能包含一条 return 语句，不能有局部变量、循环、if/else（可以用三元运算符 ?: 替代）等。
• C++14：限制被大大放宽。函数体内可以包含局部变量、循环 (for, while)、条件分支 (if, switch) 等，使其几乎和普通函数一样灵活。
• C++17 及以后：进一步放宽，例如允许在 constexpr 函数中使用 lambda 表达式。

// C++11 风格 (使用递归)
constexpr long long factorial_cpp11(int n) {
    return n <= 1 ? 1 : (n * factorial_cpp11(n - 1));
}

// C++14 风格 (可以使用循环)
constexpr long long factorial_cpp14(int n) {
    long long result = 1;
    for (int i = 2; i <= n; ++i) {
        result *= i;
    }
    return result;
}

void usage_example() {
    // 编译时计算
    constexpr long long f5 = factorial_cpp14(5); // 结果 120 在编译时就算好了
    static_assert(f5 == 120, "Calculation error!"); // 可以在编译时断言

    int arr[f5]; // OK, f5是常量表达式，可以用来定义数组大小

    // 运行时计算
    int x;
    std::cin >> x;
    long long fx = factorial_cpp14(x); // x是运行时变量，函数在运行时执行
    std::cout << "Factorial of " << x << " is " << fx << std::endl;
}

2. constexpr 在编译期的执行者与执行方式

由谁执行？(Who)

constexpr 函数在编译期的执行者是 C++ 编译器本身 (the C++ compiler).

现代编译器内部集成了一个 C++ 的解释器或虚拟机, 专门用于在编译过程中执行这类计算任务.

如何执行？(How)

这个过程可以概括为“触发、执行、替换”三部曲:

1. 触发 (Trigger): 当编译器在代码中遇到一个必须是常量表达式的上下文时（例如初始化 constexpr 变量、static_assert 的条件、数组维度等）, 就会触发对 constexpr 函数的编译期求值.
2. 执行 (Execution): 一旦触发, 编译器在其内部的一个高度受限的“沙盒”环境中模拟执行该函数. 这个执行环境非常特殊，可以理解为一个高度受限的“沙盒”：
   • 纯计算环境：它只能访问在编译期已知的数据，比如传入的常量参数（如 5）和函数内部的计算。
   • 没有外部依赖：它完全与外部世界隔离。不能进行任何 I/O 操作（如 cout, cin）、不能读写文件、不能进行动态内存分配 (new, delete)、不能调用系统 API、不能产生随机数等。
   • 确定性：对于相同的输入，结果必须永远相同。这就是为什么所有依赖运行时状态的操作都被禁止的原因。
3. 替换 (Replacement): 函数执行完毕后, 编译器会得到一个确定的常量结果. 然后, 它会用这个结果值直接替换掉源代码中原来调用函数的那段表达式. 最终生成的可执行代码中, 将不包含这个函数调用, 只有一个硬编码的常量.

例如, int arr[factorial(5)]; 在编译后, 效果等同于 int arr[120];.

class Shape {
public:
    // 在基类中声明为虚函数
    virtual void draw() const {
        std::cout << "Drawing a generic shape." << std::endl;
    }
    
    // 基类的析构函数通常也应该是虚函数(为了能够使用基类指针正确析构派生类对象)
    virtual ~Shape() {} 
};

class Circle : public Shape {
public:
    // 在派生类中重写(override)该函数
    // 'override' 关键字不是必须的, 但是一个好习惯, 它可以让编译器检查你是否真的重写了基类的虚函数
    void draw() const override {
        std::cout << "Drawing a circle." << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing a rectangle." << std::endl;
    }
};

void drawShape(const Shape& shape) {
    shape.draw(); // 现在这里会发生动态绑定
}

1. 虚函数表 (vtable)

• 当一个类声明了虚函数（或者继承了有虚函数的基类）, 编译器会为这个 类 创建一个静态的数组, 这个数组就是 虚函数表 (vtable).
• vtable 中存放的是该类所有虚函数的 地址.
• 如果派生类重写了基类的虚函数, 那么在派生类的vtable中, 相应的位置会被替换为派生类重写的那个函数的地址.

图示:

• Shape 的 vtable: [ address of Shape::draw, address of Shape::~Shape ]
• Circle 的 vtable: [ address of Circle::draw, address of Circle::~Circle ] (draw函数地址被重写了)
• Rectangle 的 vtable: [ address of Rectangle::draw, address of Rectangle::~Rectangle ]

2. 虚函数指针 (vptr)

• 当一个类拥有vtable时, 编译器会为这个类的 每一个对象 自动添加一个隐藏的成员, 这个成员就是一个指针, 叫做 虚函数指针 (vptr).
• 这个 vptr 在对象创建时（调用构造函数时）被初始化, 指向其所属类的 vtable.

图示:

// 当你创建一个 Circle 对象时
Circle c;

// c 对象的内存布局大致如下: 
[   vptr   ] --------> [ Circle's vtable   ]
[ 成员变量... ]         [ &Circle::draw     ]
                       [ &Circle::~Circle  ]
                       [ ...               ]

3. 调用过程

当执行 shape_ptr->draw(); 这样的代码时, 实际发生的步骤如下:

1. 访问 vptr: 程序通过 shape_ptr 找到它所指向的对象（可能是 Circle 或 Rectangle 对象）.
2. 找到 vtable: 程序读取该对象内部的 vptr, 找到对应的 vtable（如果是 Circle 对象, 就找到 Circle 的 vtable）.
3. 调用函数: 程序在 vtable 中查找 draw 函数对应的地址（比如它在表中的第0个位置）, 然后调用该地址上的函数.

由于 Circle 对象的 vptr 指向 Circle 的 vtable, 而 Circle 的 vtable 中存放的是 Circle::draw 的地址, 所以最终调用的就是 Circle::draw().

整个过程在运行时完成, 所以实现了动态绑定.

4. 内存布局

当类中出现虚函数时, 编译器会进行一些额外的处理来支持多态.

1. 为每个拥有虚函数的 类 创建一个 虚函数表 (vtable). 这个表是一个静态数组, 存储着虚函数的地址.
2. 在每个 对象 的内存布局的最前端, 插入一个 虚函数指针 (vptr), 这个指针指向该对象所属类的 vtable.

class Base_V {
public:
    int b_data;
    virtual void func() {}
    virtual void funcWithoutOverride() {}
    virtual ~Base_V() {}
};

class Derived_V : public Base_V {
public:
    char d_data;
    void func() override {}
    ~Derived_V() override {}
};

• 虚函数表 (vtables)

vtable 是独立于对象存在的, 每个类只有一份.

Base_V 的 vtable (vtable_Base_V)
+------------------------------+
| &Base_V::func                |  (函数指针)
+------------------------------+
| &Base_V::funcWithoutOverride |  (函数指针)
+------------------------------+
| &Base_V::~Base_V             |  (函数指针)
+------------------------------+

Derived_V 的 vtable (vtable_Derived_V)
+------------------------------+
| &Derived_V::func             |  (重写了, 地址指向派生类的函数)
+------------------------------+
| &Base_V::funcWithoutOverride |  (未被重写, 地址仍指向基类的函数)
+------------------------------+
| &Derived_V::~Derived_V       |  (重写了, 地址指向派生类的析构函数)
+------------------------------+

• 基类对象 Base_V b_v;

对象内存的开始处是一个 vptr, 指向 Base_V 的 vtable, 后面跟着成员变量.

对象 b_v 的内存布局
(大小: 8 (vptr) + 4 (int) = 12 字节, 对齐后可能是 16 字节)

+---------------------+
|       vptr          | -------> [ vtable_Base_V ]
+---------------------+
|      b_data         | (int, 4 字节)
+---------------------+
|      (padding)      | (内存对齐填充, 可能 4 字节)
+---------------------+

• 派生类对象 Derived_V d_v;

同样, 派生类对象也包含一个基类子对象. vptr 也在最前面, 但最关键的是: 这个 vptr 指向的是派生类 Derived_V 的 vtable. 这正是多态得以实现的核心.

对象 d_v 的内存布局
(大小: 8 (vptr) + 4 (int) + 1 (char) = 13 字节, 对齐后可能是 16 或 24 字节)

+----------------------+
|   |     vptr      |  | -------> [ vtable_Derived_V ]
|   +---------------+  |
|   --- 基类部分 ---    |
|   +---------------+  |
|   |    b_data     |  | (int, 4 字节)
|   +---------------+  |
|   --- 派生类部分 ---   |
|   +---------------+  |
|   |    d_data     |  | (char, 1 字节)
|   +---------------+  |
|   |   (padding)   |  | (内存对齐填充)
+----------------------+

当执行 Base_V* ptr = new Derived_V(); ptr->func(); 时:

1. ptr 指向 d_v 对象的起始地址.
2. 通过 ptr 找到对象头部的 vptr.
3. vptr 指向 vtable_Derived_V.
4. 在 vtable_Derived_V 中查找 func() 对应的函数指针, 这个指针指向 Derived_V::func().
5. 调用 Derived_V::func().

通过打印地址来认识虚函数表

#include <iostream>

class base
{
public:
    void print_nv()
    {
        std::cout << "base::print_nv" << std::endl;
    }

    virtual void print_v()
    {
        std::cout << "base::print_v" << std::endl;
    }

    virtual ~base() = default;

private:
    int a = 0;
};

class derived : public base {...};

int main()
{
    base* pArr[2]{new base(), new derived};

    // 下面两行注释输出1, 因为重载决议中匹配成员函数指针的 operator<< 函数只有将指针转换为 bool 后输出
    // std::cout << "address of base::print_v: " << reinterpret_cast<void*>(&base::print_v) << std::endl; // print: 1
    // std::cout << "address of derived::print_v: " << &derived::print_v << std::endl; // print: 1
    
    std::cout << "wtf is void(base::*)()" << std::endl; // 成员函数指针
    std::cout << "sizeof(void(base::*)()): " << sizeof(void(base::*)()) << std::endl; // 16
    std::cout << std::endl;

    std::cout << pArr[0] << "\t\t: address of *pArr[0] and also vptr" << std::endl;
    std::cout << *(reinterpret_cast<void****>(pArr[0]))
        << "\t\t: value of vptr, also address of vtable and function base::print_v" << std::endl;
    std::cout << **(reinterpret_cast<void****>(pArr[0]))
        << "\t\t: vtable[0], value of base::print_v" << std::endl;
    std::cout << ***(reinterpret_cast<void****>(pArr[0]))
        << "\t: 8 bytes of machine code in function base::print_v" << std::endl;

    delete pArr[0];
    delete pArr[1];
    return 0;
}

输出:

wtf is void(base::*)()
sizeof(void(base::*)()): 16

0x25540531a80           : address of *pArr[0] and also vptr
0x7ff6242c46d0          : value of vptr, also address of vtable and function base::print_v
0x7ff6242c2910          : vtable[0], value of base::print_v
0x20ec8348e5894855      : 8 bytes of machine code in function base::print_v