Item27--尽量少做转型动作

1. 语法选择：抛弃 C 风格，拥抱 C++ 风格

C 语言的旧式转型（C-style casts）长这样：

(T)expression  // C 风格
T(expression)  // 函数风格

Scott Meyers 强烈建议不再使用上述旧式转型，而是使用 C++ 的新式转型（C++-style casts）：

转型操作符	用途与特性
const_cast<T>(ex)	唯一能去除 const 或 volatile 属性的转型。
static_cast<T>(ex)	最常用的转型。用于隐式转换（如 int 转 double，void* 转 Typed*，基类指针转派生类指针）。不进行运行时检查。
dynamic_cast<T>(ex)	专门用于“安全向下转型”（Safe Downcasting）。它会执行运行时检查（RTTI），如果失败会返回 nullptr 或抛出异常。成本高昂。
reinterpret_cast<T>(ex)	低级转型（如 int 转 pointer）。结果取决于编译器实现（Implementation-dependent），不可移植。

为什么新式转型更好？

1. 易于辨识： 在代码中搜索 static_cast 比搜索括号 () 容易得多，方便定位所有破坏类型系统的地方。
2. 职责明确： 编译器可以协助检查意图。例如，如果你试图用 static_cast 去除 const，编译器会报错，因为它知道那是 const_cast 的工作。

---

2. 底层陷阱：转型并不只是“告诉编译器”

许多 C/C++ 程序员有一个严重误区：认为转型只是告诉编译器把一种类型当成另一种类型来看待，不会生成任何机器码。

事实：转型操作经常会产生运行时代码。

案例 A：指针偏移 (Pointer Offset)

1. 内存布局图解 (Memory Layout)

假设我们有以下三个类，Derived 同时继承了 BaseA 和 BaseB：

class BaseA { 
    int a; 
};

class BaseB { 
    int b; 
};

// 多重继承
class Derived : public BaseA, public BaseB { 
    int d; 
};

当你创建一个 Derived 对象 d 时，它在内存中的布局通常是这样的（顺序取决于编译器，但通常按继承声明顺序）：

Starting Address (0x1000) ---> +-------------+
                               | BaseA 部分  |  <-- BaseA* 指针指向这里
                               | (int a)     |
Derived* 指针指向这里 --------> +-------------+
                               | BaseB 部分  |  <-- BaseB* 指针必须指向这里！
                               | (int b)     |      (地址是 0x1004)
                               +-------------+
                               | Derived 部分|
                               | (int d)     |
                               +-------------+

2. 发生了什么？

情况 1：Derived* 转 BaseA* (首个基类)

Derived* pd = new Derived(); // 假设地址是 0x1000
BaseA* pa = pd; 

• 编译器动作： 因为 BaseA 位于 Derived 内存布局的最顶端，所以 pa 的地址通常等于 pd 的地址（0x1000）。
• 偏移量： 0。

情况 2：Derived* 转 BaseB* (第二个基类)

BaseB* pb = pd; 

• 编译器动作： 编译器知道 BaseB 是 Derived 的第二个父类，它并没有位于内存的起始位置，而是被前面的 BaseA 挤下去了。为了让 pb 能够正确地访问 BaseB 的成员（如 int b），指针必须指向 BaseB 子对象的开始位置。
• 运行时计算： 编译器会自动给地址加上一个偏移量 (Offset)。
• 结果： pb 的值变成了 0x1004。
• 结论： pb != pd，尽管它们指向同一个对象！

3. 代码验证

你可以运行这段代码来亲眼见证这个现象：

#include <iostream>

class BaseA { public: int a; };
class BaseB { public: int b; };
class Derived : public BaseA, public BaseB { public: int d; };

int main() {
    Derived d;
    
    // 获取指针
    Derived* pDerived = &d;
    BaseA* pA = &d;    // 隐式 static_cast
    BaseB* pB = &d;    // 隐式 static_cast，发生指针偏移！

    // 打印地址 (强转为 void* 否则 cout 可能会重载输出)
    std::cout << "Derived address: " << (void*)pDerived << std::endl;
    std::cout << "BaseA address:   " << (void*)pA << std::endl;
    std::cout << "BaseB address:   " << (void*)pB << std::endl;

    if (pDerived == pA) std::cout << "pDerived == pA" << std::endl;
    
    // 注意：C++ 在比较指针时很聪明，如果你写 pDerived == pB，
    // 编译器会自动把 pDerived 加上偏移量后再比较，所以逻辑上是相等的。
    // 但物理地址确实不同。
    
    return 0;
}

输出示例（地址会变，但相对关系不变）：

Derived address: 0x7ffdee605a10
BaseA address:   0x7ffdee605a10  <-- 一样
BaseB address:   0x7ffdee605a14  <-- 不一样！增加了 4 字节 (sizeof int)

4. 为什么 reinterpret_cast 是危险的？

回到 Item 27 的警告。如果你使用 C++ 的标准转型（隐式或 static_cast），编译器知道类之间的继承关系，它会帮你计算这个偏移量：

• BaseB* pb = static_cast<BaseB*>(pDerived); -> 编译器生成代码：pb = pDerived + 4。这是正确的。

如果你使用 reinterpret_cast：

• BaseB* pb = reinterpret_cast<BaseB*>(pDerived); -> 编译器被强制闭嘴：pb = pDerived。
• 后果： pb 指向了 0x1000。当你通过 pb 访问 BaseB 的成员 b 时，你实际上是在访问地址 0x1000 处的数据。但那个位置放的是 BaseA 的成员 a！
• 结局： 数据错乱（读取了错误的字段）或者程序崩溃。

总结

1. 物理地址不同： 在多重继承中，指向同一个对象的不同基类指针，其物理内存地址很可能是不一样的。
2. this 指针调整： 这种机制被称为 "this pointer adjustment"。编译器在调用成员函数或赋值时，会在幕后默默地加减这个偏移量。
3. 不要瞎转： 只有 static_cast（或 dynamic_cast）知道如何在类层次结构中正确调整这些偏移量。reinterpret_cast 仅仅是按位拷贝指针的值，完全忽略对象模型，因此在涉及继承层级转换时极其危险。

假设你想在派生类的函数中先调用基类的同名函数：

错误写法：

C++

class Window {
public:
    virtual void onResize() { ... }
};

class SpecialWindow : public Window {
public:
    virtual void onResize() {
        // 意图：调用父类的 onResize
        // 实际：创建了一个 *临时副本*，修改了那个副本，然后副本被销毁！
        static_cast<Window>(*this).onResize(); 
        
        // ... 继续 SpecialWindow 的逻辑
    }
};

原因解析： static_cast<Window>(*this) 会将 *this 转型为一个 Window 对象（注意不是指针或引用）。这会触发拷贝构造函数，生成一个临时的 Window 对象。onResize 是在这个临时对象上调用的。当前对象 *this 根本没变。

正确写法：

    virtual void onResize() {
        Window::onResize(); // 直接调用基类函数作用于当前对象
        // ...
    }

---

3. 性能影响：警惕 dynamic_cast

dynamic_cast 是 C++ 转型中性能开销最大的。

• 它依赖 RTTI (Run-Time Type Identification)。
• 在许多实现中（特别是涉及深度继承或多重继承时），dynamic_cast 可能需要进行字符串比较（类名匹配），这非常慢。

如何避免使用 dynamic_cast？

如果你发现自己写了这样的代码：

// 糟糕的设计：根据类型做不同操作
if (SpecialWindow* psw = dynamic_cast<SpecialWindow*>(pw)) {
    psw->blink();
} else if (OtherWindow* pow = dynamic_cast<OtherWindow*>(pw)) {
    pow->rotate();
}

替代方案 1：使用虚函数

将 blink() 或 rotate() 抽象为基类的虚函数（哪怕是空实现），利用多态自动分发。

替代方案 2：使用类型安全的容器

如果不想污染基类，可以使用 std::vector<SpecialWindow> 直接存储特定类型的指针，而不是全部存为 Window。

---

总结 (Summary)

1. 首选 C++ 新式转型：static_cast, const_cast 等，因为它们更精准且易于查找。
2. 转型可能生成代码：别以为转型只是编译期的事，它可能涉及指针偏移或对象拷贝（尤其是转型为值而非引用时）。
3. 避免 dynamic_cast：如果必须用，确保它不在性能敏感的热点代码（Hot Path）中。通常可以通过更好的接口设计（虚函数）来避免它。
4. 绝招：如果必须转型，把它封装在函数里，不要让混乱的转型代码散落在业务逻辑中。