类型转换

// C 风格：(T)expr —— 什么都做，不安全
double d = 3.14;
int x = (int)d;           // 可能是 static_cast
const int* p = &x;
int* q = (int*)p;         // 可能是 const_cast（危险！）

// C++ 风格：明确意图
int x2 = static_cast<int>(d);          // 明确：数值转换
int* q2 = const_cast<int*>(p);         // 明确：去除 const（我知道这是危险的）

#include <iostream>
#include <iomanip>

class Base {
public:
    void base_func() { std::cout << "Base::base_func()" << std::endl; }
};

class Derived : public Base {
public:
    void derived_func() { std::cout << "Derived::derived_func()" << std::endl; }
};

void process_data(double* data, size_t size) {
    std::cout << "处理 " << size << " 个数据" << std::endl;
}

int main() {
    std::cout << "===== 数值转换 =====" << std::endl;

    // 明确精度损失意图
    double pi = 3.1415926;
    int int_pi = static_cast<int>(pi);
    std::cout << "pi = " << pi << ", static_cast<int>(pi) = " << int_pi << std::endl;

    // 强制浮点除法（而非整型除法）
    int a = 5, b = 2;
    double ratio = static_cast<double>(a) / b;
    std::cout << "5/2 = " << ratio << " (不会截断)" << std::endl;

    // 枚举与整数互转
    enum class Color : int { Red = 1, Green = 2, Blue = 3 };
    Color c = Color::Blue;
    int color_val = static_cast<int>(c);
    std::cout << "Color::Blue = " << color_val << std::endl;

    std::cout << "\n===== 指针转换(非多态) =====" << std::endl;

    // 派生类指针 → 基类指针（向上转换，安全）
    Derived d;
    Base* bp = static_cast<Base*>(&d);
    bp->base_func();

    // void* ↔ T*（从 C API 取回类型）
    void* vp = static_cast<void*>(&d);
    Derived* dp_back = static_cast<Derived*>(vp);
    dp_back->derived_func();

    // 阻止危险的向下转换（非多态）
    Base b;
    // Derived* bad = static_cast<Derived*>(&b);  // 编译通过，但运行时是 UB
    // bad->derived_func();  // 访问不存在的成员 → 未定义行为

    std::cout << "\n===== 与 C 风格转换对比 =====" << std::endl;

    // C 风格：可能做多种转换，难以审查
    // double* → int* 的 C 风格转换在编译期无法发现问题
    // static_cast 则会拒绝：double* 和 int* 不是相关类型
    // int* ip = static_cast<int*>(&pi);  // 编译错误

    return 0;
}

#include <iostream>
#include <vector>
#include <memory>
#include <cmath>

class Shape {
public:
    virtual ~Shape() = default;
    virtual double area() const = 0;
    virtual void describe() const {
        std::cout << "形状" << std::endl;
    }
};

class Circle : public Shape {
public:
    explicit Circle(double r) : radius_(r) {}

    double area() const override {
        return M_PI * radius_ * radius_;
    }

    void describe() const override {
        std::cout << "圆形 (半径=" << radius_
                  << ", 面积=" << area() << ")" << std::endl;
    }

    double radius() const { return radius_; }

private:
    double radius_;
};

class Rectangle : public Shape {
public:
    Rectangle(double w, double h) : width_(w), height_(h) {}

    double area() const override {
        return width_ * height_;
    }

    void describe() const override {
        std::cout << "矩形 (宽=" << width_
                  << ", 高=" << height_
                  << ", 面积=" << area() << ")" << std::endl;
    }

    bool is_square() const {
        return std::abs(width_ - height_) < 1e-9;
    }

private:
    double width_, height_;
};

// 仅对圆形进行特殊处理（如放大半径）
void enlarge_if_circle(Shape* shape, double factor) {
    // dynamic_cast 在运行期检查实际类型
    Circle* circle = dynamic_cast<Circle*>(shape);
    if (circle) {
        std::cout << "  放大圆形（原半径=" << circle->radius() << "）"
                  << std::endl;
    } else {
        std::cout << "  不是圆形，跳过" << std::endl;
    }
}

// 统计正方形数量
size_t count_squares(const std::vector<std::unique_ptr<Shape>>& shapes) {
    size_t count = 0;
    for (const auto& s : shapes) {
        // 先转换为 Rectangle*，再判断是否为正方形
        auto* rect = dynamic_cast<Rectangle*>(s.get());
        if (rect && rect->is_square()) {
            ++count;
        }
    }
    return count;
}

int main() {
    std::vector<std::unique_ptr<Shape>> shapes;

    shapes.push_back(std::make_unique<Circle>(3.0));
    shapes.push_back(std::make_unique<Rectangle>(4.0, 4.0));  // 正方形
    shapes.push_back(std::make_unique<Circle>(2.0));
    shapes.push_back(std::make_unique<Rectangle>(5.0, 3.0));

    std::cout << "===== 所有形状 =====" << std::endl;
    for (const auto& s : shapes) {
        s->describe();
    }

    std::cout << "\n===== 尝试放大圆形 =====" << std::endl;
    for (auto& s : shapes) {
        enlarge_if_circle(s.get(), 2.0);
    }

    std::cout << "\n正方形数量: " << count_squares(shapes) << std::endl;

    // dynamic_cast 对引用：失败抛出 std::bad_cast
    Shape& ref = *shapes[0];
    try {
        auto& circle_ref = dynamic_cast<Circle&>(ref);
        std::cout << "\n第一项是圆形，半径=" << circle_ref.radius() << std::endl;
    } catch (const std::bad_cast& e) {
        std::cout << "转换失败: " << e.what() << std::endl;
    }

    // 错误演示：对非多态类型使用 dynamic_cast
    // class NonPoly {}; NonPoly np;
    // dynamic_cast<int*>(&np);  // 编译错误：非多态类型

    return 0;
}

#include <iostream>
#include <cstring>

// const_cast 的正当用途：兼容遗留 C API
void legacy_c_function(char* str) {
    // 遗留代码不保证不修改，但实际上这里只读
    std::cout << "C 函数收到: " << str << std::endl;
}

// 安全的包装函数
void safe_wrapper(const char* str) {
    // 我们知道 legacy_c_function 实际上不修改 str
    legacy_c_function(const_cast<char*>(str));
}

int main() {
    // ---- const_cast ----
    const char* msg = "Hello, const world";
    safe_wrapper(msg);

    // 危险示例：试图修改真正的 const 对象
    const int ci = 42;
    // int* p = const_cast<int*>(&ci);
    // *p = 100;            // 未定义行为！ci 存储在只读区域

    // ---- reinterpret_cast ----
    // 正当用途：网络编程中解析字节流
    uint32_t ip_addr = 0xC0A80001;  // 192.168.0.1
    uint8_t* bytes = reinterpret_cast<uint8_t*>(&ip_addr);
    std::cout << "\nIP 地址字节: ";
    for (int i = 0; i < 4; ++i) {
        std::cout << static_cast<int>(bytes[i]);
        if (i < 3) std::cout << ".";
    }
    std::cout << std::endl;

    // 注意：reinterpret_cast 不改变位模式，只改变解释方式
    float f = 3.14f;
    uint32_t bits = reinterpret_cast<uint32_t&>(f);
    std::cout << "3.14f 的 IEEE 754 位模式: 0x"
              << std::hex << bits << std::dec << std::endl;

    return 0;
}