Chapter 15 友元、异常和其他

class HostClass {
    friend ReturnType friendFunctionName(parameters); // 声明友元函数
    friend class FriendClassName;                    // 声明友元类
    friend ReturnType AnotherClass::memberFuncName(parameters); // 声明友元成员函数
private:
    int privateData;
protected:
    int protectedData;
public:
    // ...
};

// tv.h -- Tv and Remote classes
#ifndef TV_H_
#define TV_H_

class Tv; // 前向声明 Tv 类，因为 Remote 会用到它

class Remote {
public:
    enum State { Off, On };
    enum { MinVal, MaxVal = 20 };
    enum { Antenna, Cable };
    enum { TV, DVD }; // 假设遥控器也可以控制 DVD
private:
    int mode; // 控制 TV 还是 DVD
public:
    Remote(int m = TV) : mode(m) {}
    // 遥控器的方法，需要访问 Tv 的私有成员
    bool volup(Tv & t); // 引用 Tv 对象
    bool voldown(Tv & t);
    void onoff(Tv & t);
    void chanup(Tv & t);
    void chandown(Tv & t);
    void set_mode(Tv & t);
    void set_input(Tv & t);
    void set_chan(Tv & t, int c);
};

class Tv {
private:
    int state;      // On or Off
    int volume;     // assumed to be digitized
    int maxchannel; // maximum number of channels
    int channel;    // current channel setting
    int mode;       // Antenna or Cable
    int input;      // TV or DVD
public:
    // 将 Remote 类声明为 Tv 类的友元
    friend class Remote;

    enum State { Off, On };
    enum { MinVal, MaxVal = 20 };
    enum { Antenna, Cable };
    enum { TV, DVD };

    Tv(int s = Off, int mc = 125) : state(s), volume(5),
        maxchannel(mc), channel(2), mode(Cable), input(TV) {}
    void onoff() { state = (state == On) ? Off : On; }
    bool ison() const { return state == On; }
    bool volup();
    bool voldown();
    void chanup();
    void chandown();
    void set_mode() { mode = (mode == Antenna) ? Cable : Antenna; }
    void set_input() { input = (input == TV) ? DVD : TV; }
    void settings() const; // display all settings
};

// Remote 方法的实现 (需要看到 Tv 的完整定义)
// 通常放在 .cpp 文件中，或者在 Tv 定义之后

inline bool Remote::volup(Tv & t) { return t.volup(); } // 调用 Tv 的公有方法
inline bool Remote::voldown(Tv & t) { return t.voldown(); }
inline void Remote::onoff(Tv & t) { t.onoff(); }
inline void Remote::chanup(Tv & t) { t.chanup(); }
inline void Remote::chandown(Tv & t) { t.chandown(); }
inline void Remote::set_mode(Tv & t) { t.set_mode(); }
inline void Remote::set_input(Tv & t) { t.set_input(); }
// set_chan 需要直接访问 Tv 的私有成员 channel
inline void Remote::set_chan(Tv & t, int c) {
    // 因为 Remote 是 Tv 的友元，可以直接访问 t.channel
    t.channel = c;
}

// Tv 方法的实现 (部分)
inline bool Tv::volup() {
    if (volume < MaxVal) {
        volume++;
        return true;
    } else return false;
}
inline bool Tv::voldown() {
    if (volume > MinVal) {
        volume--;
        return true;
    } else return false;
}
inline void Tv::chanup() {
    if (channel < maxchannel) channel++;
    else channel = 1;
}
inline void Tv::chandown() {
    if (channel > 1) channel--;
    else channel = maxchannel;
}
// ... settings() 实现需要 iostream ...

#endif // TV_H_

// use_tv.cpp -- 使用 Tv 和 Remote
#include <iostream>
#include "tv.h"

// Tv::settings() 实现
void Tv::settings() const {
    using std::cout;
    using std::endl;
    cout << "TV is " << (state == On ? "On" : "Off") << endl;
    if (state == On) {
        cout << "Volume setting = " << volume << endl;
        cout << "Channel setting = " << channel << endl;
        cout << "Mode = " << (mode == Antenna ? "antenna" : "cable") << endl;
        cout << "Input = " << (input == TV ? "TV" : "DVD") << endl;
    }
}

int main() {
    using std::cout;
    Tv s42;
    cout << "Initial settings for 42\" TV:\n";
    s42.settings();
    s42.onoff(); // 打开电视
    s42.chanup(); // 增加频道
    cout << "\nAdjusted settings for 42\" TV:\n";
    s42.settings();

    Remote grey; // 创建遥控器
    grey.set_chan(s42, 10); // 遥控器设置频道 (调用友元可访问的私有成员)
    grey.volup(s42);      // 遥控器增加音量
    grey.volup(s42);
    cout << "\nSettings after using remote:\n";
    s42.settings();

    Tv s58(Tv::On); // 创建一个已打开的电视
    s58.set_mode(); // 切换模式
    grey.set_chan(s58, 28); // 遥控器控制另一台电视
    cout << "\nSettings for 58\" TV:\n";
    s58.settings();

    return 0;
}

class HostClass {
    // ...
    // 声明 OtherClass 的 memberFunc 为友元
    friend ReturnType OtherClass::memberFunc(parameters);
    // ...
};

// tvfm.h -- Tv and Remote classes using a friend member
#ifndef TVFM_H_
#define TVFM_H_

class Tv; // *** 1. 前向声明 Tv ***

class Remote {
    // ... (Remote 定义同前) ...
public:
    // ...
    void set_chan(Tv & t, int c); // 声明 set_chan
    // ...
};

class Tv {
    // ... (Tv 定义同前) ...
public:
    // *** 2. 将 Remote::set_chan 声明为友元 ***
    friend void Remote::set_chan(Tv & t, int c);
    // ...
};

// *** 3. 定义 Remote::set_chan (需要看到 Tv 的完整定义) ***
inline void Remote::set_chan(Tv & t, int c) {
    t.channel = c; // 现在可以访问 Tv 的私有成员 channel
}

// ... (其他 Remote 和 Tv 的内联方法定义) ...

#endif // TVFM_H_

class ClassB; // 前向声明

class ClassA {
    friend class ClassB; // B 是 A 的友元
private:
    int dataA;
};

class ClassB {
    friend class ClassA; // A 是 B 的友元
private:
    int dataB;
public:
    void processA(ClassA& a) {
        a.dataA = 10; // B 可以访问 A 的私有成员
    }
};

// ClassA 的成员函数实现需要看到 ClassB 的完整定义
// void ClassA::processB(ClassB& b) { b.dataB = 20; }

class ClassC; // 前向声明

class ClassD {
    friend void sharedFriend(const ClassC& c, const ClassD& d);
private:
    int dataD;
};

class ClassC {
    friend void sharedFriend(const ClassC& c, const ClassD& d);
private:
    int dataC;
};

// 共同友元的实现
void sharedFriend(const ClassC& c, const ClassD& d) {
    std::cout << "C data: " << c.dataC << ", D data: " << d.dataD << std::endl;
}

class EnclosingClass {
private:
    // 嵌套类可以有自己的访问控制
    class NestedClassPrivate {
        // ...
    };
protected:
    class NestedClassProtected {
        // ...
    };
public:
    class NestedClassPublic {
    private:
        int nestedData;
        EnclosingClass* enclosingPtr; // 可以持有外围类指针
    public:
        NestedClassPublic(EnclosingClass* enc = nullptr) : enclosingPtr(enc) {}
        void accessEnclosing(EnclosingClass& enc);
        int getData() const { return nestedData; }
    };

private:
    int enclosingData;
    NestedClassPrivate ncp; // 可以创建嵌套类对象作为成员
public:
    EnclosingClass(int data = 0) : enclosingData(data) {}
    void useNested(NestedClassPublic& ncp);
    int getData() const { return enclosingData; }
};

// 嵌套类成员函数的定义
void EnclosingClass::NestedClassPublic::accessEnclosing(EnclosingClass& enc) {
    // 嵌套类可以访问外围类的所有成员 (通过对象/指针/引用)
    std::cout << "Accessing enclosing data: " << enc.enclosingData << std::endl;
    // enc.ncp; // 可以访问外围类的私有成员对象
}

// 外围类成员函数的定义
void EnclosingClass::useNested(NestedClassPublic& ncp) {
    // 外围类可以访问嵌套类的 public 成员
    std::cout << "Using nested data: " << ncp.getData() << std::endl;
    // std::cout << ncp.nestedData; // 错误！不能直接访问嵌套类的 private 成员
}

// queue.h (部分)
#ifndef QUEUE_H_
#define QUEUE_H_

class Customer; // 前向声明
typedef Customer Item;

class Queue {
private:
    // 嵌套结构 Node (作用域在 Queue 内)
    // 设为 private，因为它是 Queue 的实现细节
    struct Node {
        Item item;
        Node * next;
    };
    enum { Q_SIZE = 10 };

    Node * front; // 指向 Node 对象的指针
    Node * rear;
    int items;
    const int qsize;
    // ... (禁止赋值) ...
public:
    Queue(int qs = Q_SIZE);
    ~Queue();
    bool isempty() const;
    bool isfull() const;
    int queuecount() const;
    bool enqueue(const Item &item); // Queue 的方法可以创建和访问 Node 对象
    bool dequeue(Item &item);
};
#endif

// queue.cpp (部分)
#include "queue.h"
// ... Customer 定义 ...

Queue::Queue(int qs) : qsize(qs) {
    front = rear = nullptr;
    items = 0;
}

Queue::~Queue() {
    Node * temp; // 可以声明 Node 类型的指针
    while (front != nullptr) {
        temp = front;
        front = front->next; // 可以访问 Node 的成员 (因为 Node 是 Queue 的嵌套类，且成员默认 public)
        delete temp;
    }
}

bool Queue::enqueue(const Item &item) {
    if (isfull())
        return false;
    Node * add = new Node; // 可以创建 Node 对象
    add->item = item;      // 可以访问 Node 的成员
    add->next = nullptr;
    items++;
    if (front == nullptr)
        front = add;
    else
        rear->next = add;
    rear = add;
    return true;
}
// ... dequeue 实现类似 ...

template <typename T>
class OuterTemplate {
private:
    T outerData;

public:
    // 嵌套类
    class Nested {
    private:
        int nestedData;
    public:
        // 嵌套类的成员函数可以访问外围模板类的成员
        // (需要通过外围类对象)
        void processOuter(OuterTemplate<T>& outer) {
            std::cout << "Outer data: " << outer.outerData << std::endl;
            // outer.outerData = someValue; // 可以修改
        }
    };

private:
    Nested nestedObj; // 外围类可以包含嵌套类对象

public:
    OuterTemplate(const T& data) : outerData(data) {}

    void useNested() {
        nestedObj.processOuter(*this);
    }
};

// 使用
int main() {
    OuterTemplate<double> ot(3.14);
    ot.useNested(); // 输出 Outer data: 3.14

    // 引用嵌套类类型需要外围类模板实例化
    OuterTemplate<double>::Nested nestedInstance;
    // nestedInstance.processOuter(ot); // 也可以直接调用

    return 0;
}

#include <iostream>
#include <cstdlib> // for abort()

double hmean(double a, double b) {
    if (a == -b) {
        std::cerr << "Error: hmean() arguments a = -b not allowed.\n";
        std::abort(); // 终止程序
    }
    return 2.0 * a * b / (a + b);
}

int main() {
    double result = hmean(10.0, -10.0);
    // 这行不会执行
    std::cout << "Result: " << result << std::endl;
    return 0;
}

#include <iostream>
#include <cerrno> // for errno (C-style error reporting)

// 返回 -1 表示错误
int process_data(int input) {
    if (input < 0) {
        errno = EDOM; // 设置全局错误码 (Domain Error)
        return -1;    // 返回错误码
    }
    // ... process data ...
    return 0; // 返回 0 表示成功
}

int main() {
    if (process_data(-5) == -1) {
        if (errno == EDOM) {
            std::cerr << "Error: Invalid input detected.\n";
        } else {
            std::cerr << "An unknown error occurred.\n";
        }
        // ... 处理错误 ...
    } else {
        std::cout << "Processing successful.\n";
    }
    return 0;
}

#include <iostream>
#include <stdexcept> // 包含标准异常类，如 std::runtime_error

double hmean_exc(double a, double b) {
    if (a == -b) {
        // 抛出一个 runtime_error 类型的异常对象
        throw std::runtime_error("hmean(): invalid arguments: a = -b");
    }
    return 2.0 * a * b / (a + b);
}

int main() {
    double x, y, z;
    std::cout << "Enter two numbers: ";
    while (std::cin >> x >> y) {
        try { // ---- try block starts ----
            z = hmean_exc(x, y);
            std::cout << "Harmonic mean of " << x << " and " << y
                      << " is " << z << std::endl;
        } // ---- try block ends ----
        catch (const std::runtime_error & e) { // ---- catch block starts ----
            // 捕获 runtime_error 类型的异常 (及其派生类)
            std::cerr << "Error caught: " << e.what() << std::endl; // what() 返回错误信息字符串
            std::cout << "Enter a new pair of numbers: ";
            continue; // 继续下一次循环输入
        } // ---- catch block ends ----

        std::cout << "Enter next set of numbers <q to quit>: ";
    }
    std::cout << "Bye!\n";
    return 0;
}

#include <iostream>
#include <string>
#include <cmath> // for sqrt

// 自定义异常基类 (可以继承自 std::exception)
class MathError {
public:
    virtual void report() const { std::cerr << "Math error\n"; }
    virtual ~MathError() {} // 虚析构函数很重要
};

// 派生异常类：无效参数
class BadArgument : public MathError {
private:
    double arg1;
    double arg2; // 可能有多个参数
    std::string funcName;
public:
    BadArgument(double a1, double a2, const std::string& fname)
        : arg1(a1), arg2(a2), funcName(fname) {}
    virtual void report() const override {
        std::cerr << "Bad arguments to function " << funcName << "(): "
                  << arg1 << ", " << arg2 << std::endl;
    }
};

// 派生异常类：定义域错误
class DomainError : public MathError {
private:
    double value;
    std::string funcName;
public:
    DomainError(double val, const std::string& fname)
        : value(val), funcName(fname) {}
    virtual void report() const override {
        std::cerr << "Domain error in function " << funcName << "(): "
                  << "Invalid value " << value << std::endl;
    }
};

// 函数可能抛出异常
double my_sqrt(double x) {
    if (x < 0.0) {
        throw DomainError(x, "my_sqrt"); // 抛出 DomainError 对象
    }
    return std::sqrt(x);
}

double hmean_exc2(double a, double b) {
     if (a == -b) {
        throw BadArgument(a, b, "hmean_exc2"); // 抛出 BadArgument 对象
    }
    return 2.0 * a * b / (a + b);
}


int main() {
    double a = 10.0, b = -10.0;
    double c = -5.0;

    try {
        std::cout << "Calculating hmean...\n";
        double result1 = hmean_exc2(a, b);
        std::cout << "Hmean result: " << result1 << std::endl; // 不会执行

        std::cout << "Calculating sqrt...\n";
        double result2 = my_sqrt(c);
        std::cout << "Sqrt result: " << result2 << std::endl; // 不会执行
    }
    // catch 块的顺序很重要：派生类应在基类之前
    catch (const BadArgument& bae) {
        std::cerr << "Caught BadArgument: ";
        bae.report();
    }
    catch (const DomainError& de) {
        std::cerr << "Caught DomainError: ";
        de.report();
    }
    catch (const MathError& me) { // 捕获所有 MathError 及其派生类
        std::cerr << "Caught generic MathError: ";
        me.report();
    }
    catch (...) { // 捕获任何其他类型的异常
        std::cerr << "Caught an unknown exception!\n";
    }

    std::cout << "Program continues after catch.\n";
    return 0;
}

void func1() throw(BadArgument, DomainError); // 可能抛出 BadArgument 或 DomainError
void func2() throw(); // 保证不抛出任何异常
void func3(); // 可能抛出任何类型的异常 (默认)

#include <memory> // for std::unique_ptr
#include <stdexcept>

void process_resource() {
    std::unique_ptr<int> p_res(new int(10)); // RAII: 资源由 unique_ptr 管理

    // ... 使用 p_res ...

    if (/* some error condition */ true) {
        throw std::runtime_error("Something went wrong in process_resource");
    }

    // ... 更多代码 ...

} // 如果正常结束，p_res 在这里销毁，释放内存
  // 如果抛出异常，栈解退时 p_res 也会被销毁，释放内存

void caller() {
    try {
        process_resource();
    } catch (const std::runtime_error& e) {
        // 处理异常
    }
}

#include <stdexcept> // 包含 runtime_error, logic_error 等
#include <string>

class MyLogicError : public std::logic_error {
public:
    explicit MyLogicError(const std::string& what_arg)
        : std::logic_error(what_arg) {}
    // what() 会继承 std::logic_error 的实现，返回构造时传入的字符串
};

int main() {
    try {
        throw MyLogicError("Custom logic error occurred");
    }
    catch (const std::exception& e) { // 捕获所有标准异常及派生类
        std::cerr << "Caught standard exception: " << e.what() << std::endl;
    }
    return 0;
}

#include <iostream>
#include <cstdlib> // for rand(), srand()
#include <ctime>   // for time()
#include <typeinfo> // for bad_cast
#include <stdexcept> // for exception

class Grand {
private:
    int hold;
public:
    Grand(int h = 0) : hold(h) {}
    virtual void Speak() const { std::cout << "I am a grand class!\n"; }
    virtual int Value() const { return hold; }
    virtual ~Grand() {} // 虚析构函数
};

class Superb : public Grand {
public:
    Superb(int h = 0) : Grand(h) {}
    void Speak() const override { std::cout << "I am a superb class!!\n"; }
    virtual void Say() const { std::cout << "I hold the superb value of " << Value() << "!\n"; }
};

class Magnificent : public Superb {
private:
    char ch;
public:
    Magnificent(int h = 0, char c = 'A') : Superb(h), ch(c) {}
    void Speak() const override { std::cout << "I am a magnificent class!!!\n"; }
    void Say() const override { std::cout << "I hold the magnificent value of " << Value() << " and the character " << ch << "!\n"; }
};

// 函数：随机生成一个指向 Grand, Superb 或 Magnificent 对象的指针
Grand * GetOne() {
    Grand * p = nullptr;
    switch (std::rand() % 3) {
        case 0: p = new Grand(std::rand() % 100); break;
        case 1: p = new Superb(std::rand() % 100); break;
        case 2: p = new Magnificent(std::rand() % 100, 'A' + std::rand() % 26); break;
    }
    return p;
}

int main() {
    std::srand(std::time(0));
    Grand * pg;
    Superb * ps;
    Magnificent * pm;

    for (int i = 0; i < 5; i++) {
        pg = GetOne(); // 获取一个随机类型的对象指针
        std::cout << "Now processing type #" << i+1 << std::endl;
        pg->Speak(); // 调用虚函数，总是正确的

        // 尝试向下转换为 Superb*
        ps = dynamic_cast<Superb *>(pg);
        if (ps != nullptr) { // 检查转换是否成功
            ps->Say(); // 如果是 Superb 或 Magnificent，可以调用 Say()
        } else {
            std::cout << " (Not a Superb or derived type)\n";
        }

        // 尝试向下转换为 Magnificent*
        pm = dynamic_cast<Magnificent *>(pg);
        if (pm != nullptr) {
             // 如果是 Magnificent，可以调用 Say() (这里会调用 Magnificent 的版本)
             // pm->Say(); // 可以调用，但上面 Superb* 的 Say() 已经调用过了
             std::cout << "   (Also a Magnificent type)\n";
        }

        // 尝试使用引用转换 (如果失败会抛异常)
        try {
            Superb & rs = dynamic_cast<Superb &>(*pg); // 尝试转换为 Superb 引用
            std::cout << "  Reference cast to Superb successful.\n";
            // rs.Say(); // 可以调用
        } catch (const std::bad_cast & bc) {
            std::cout << "  Reference cast to Superb failed: " << bc.what() << std::endl;
        }

        delete pg; // 清理内存 (需要虚析构函数)
        std::cout << "--------------------\n";
    }
    return 0;
}

#include <iostream>
#include <typeinfo> // for typeid, type_info
#include <cstdlib>
#include <ctime>

// 使用上面定义的 Grand, Superb, Magnificent 类和 GetOne() 函数

int main() {
    std::srand(std::time(0));
    Grand * pg = nullptr;

    for (int i = 0; i < 5; i++) {
        pg = GetOne();
        std::cout << "Pointer pg type (static): " << typeid(pg).name() << std::endl; // 指针本身的类型
        if (pg != nullptr) {
            // 对指针解引用，获取运行时类型信息 (因为 Grand 有虚函数)
            std::cout << "Object pointed to by pg (runtime): " << typeid(*pg).name() << std::endl;

            // 比较类型信息
            if (typeid(*pg) == typeid(Grand)) {
                std::cout << "  It's exactly a Grand object.\n";
            } else if (typeid(*pg) == typeid(Superb)) {
                std::cout << "  It's exactly a Superb object.\n";
            } else if (typeid(*pg) == typeid(Magnificent)) {
                std::cout << "  It's exactly a Magnificent object.\n";
            }

            // 检查是否是某种类型或其派生类 (通常 dynamic_cast 更适合)
            // 注意：typeid 比较的是精确类型，不会考虑继承关系
            if (dynamic_cast<Superb*>(pg)) { // 检查是否是 Superb 或其派生类
                 std::cout << "  It's a Superb or derived from Superb.\n";
            }

            delete pg;
            pg = nullptr;
        }
        std::cout << "--------------------\n";
    }

    // 对空指针使用 typeid 会抛异常
    try {
        std::cout << "Type of *nullptr: " << typeid(*pg).name() << std::endl;
    } catch (const std::bad_typeid& bt) {
        std::cerr << "Caught bad_typeid exception: " << bt.what() << std::endl;
    }

    return 0;
}

#include <iostream>

class Base { public: virtual ~Base() {} }; // 多态基类
class Derived : public Base {};

int main() {
    // 基本类型转换
    double pi = 3.14159;
    int integer_pi = static_cast<int>(pi); // double to int (截断)
    std::cout << "integer_pi: " << integer_pi << std::endl; // 输出 3

    // 向上转换 (安全)
    Derived d;
    Base* pb = &d; // 隐式转换即可
    Base* pb_static = static_cast<Base*>(&d); // 显式向上转换

    // 向下转换 (不安全，需程序员保证)
    Base* pb_maybe_d = new Derived();
    // 假设我们确定 pb_maybe_d 指向 Derived
    Derived* pd_static = static_cast<Derived*>(pb_maybe_d);
    std::cout << "Static downcast successful (programmer assumed).\n";
    delete pb_maybe_d;

    Base* pb_not_d = new Base();
    // !! 危险 !! pb_not_d 实际指向 Base，但我们强制转为 Derived*
    // Derived* pd_wrong = static_cast<Derived*>(pb_not_d);
    // pd_wrong->someDerivedMethod(); // *** 未定义行为 ***
    delete pb_not_d;

    // void* 转换
    int i = 10;
    void* vp = static_cast<void*>(&i); // int* to void*
    int* ip = static_cast<int*>(vp);   // void* back to int*
    std::cout << "Value via void*: " << *ip << std::endl; // 输出 10

    return 0;
}

#include <iostream>

// 假设有一个旧的 C 函数，它接受 char* 但保证不修改内容
void legacy_print(char* str) {
    std::cout << "Legacy print: " << str << std::endl;
}

int main() {
    const char* const_message = "Hello";

    // 调用 legacy_print 需要 char*，但我们只有 const char*
    // 我们知道 legacy_print 不会修改，所以使用 const_cast
    char* non_const_message = const_cast<char*>(const_message);
    legacy_print(non_const_message); // OK

    const int constant_value = 100;
    const int* p_const = &constant_value;

    // 尝试移除 const 并修改
    int* p_non_const = const_cast<int*>(p_const);
    // *p_non_const = 200; // *** 未定义行为！*** 因为 constant_value 本身是 const

    int variable_value = 50;
    const int* p_const_var = &variable_value;
    int* p_non_const_var = const_cast<int*>(p_const_var);
    *p_non_const_var = 60; // OK，因为 variable_value 本身不是 const
    std::cout << "variable_value: " << variable_value << std::endl; // 输出 60

    return 0;
}

#include <iostream>
#include <cstdint> // for uintptr_t

struct Data {
    int a;
    double b;
};

int main() {
    int i = 65; // ASCII 'A'

    // 指针类型转换 (危险)
    int* pi = &i;
    // 将 int* 重新解释为 char*
    char* pc = reinterpret_cast<char*>(pi);
    // 结果取决于系统字节序 (endianness)
    std::cout << "Reinterpreted char: " << *pc << std::endl; // 可能输出 'A' 或其他

    // 指针与整数转换
    uintptr_t addr_val = reinterpret_cast<uintptr_t>(pi); // 指针转整数
    std::cout << "Address as integer: " << std::hex << addr_val << std::endl;
    int* pi_back = reinterpret_cast<int*>(addr_val); // 整数转回指针
    std::cout << "Value via int->ptr->int: " << std::dec << *pi_back << std::endl; // 输出 65

    // 不相关指针类型转换 (非常危险)
    Data d = {1, 3.14};
    Data* pd = &d;
    // 将 Data* 重新解释为 int*
    int* p_int_from_data = reinterpret_cast<int*>(pd);
    // 访问 *p_int_from_data 通常会得到 d.a 的值 (取决于内存布局)
    std::cout << "Reinterpreted int from Data*: " << *p_int_from_data << std::endl; // 可能输出 1

    return 0;
}