NULL vs nullptr：你不知道的危险真相

// 👇 老式的指针初始化方式
int* ptr = NULL;  // 或者 int* ptr = 0; 
                  // ⚠️ 这两种方式都可能引起混淆

// 🎭 这里有两个看似相似但完全不同的函数
void welcome(int* hero) {    // 👈 期望接收一个指针
    cout << "欢迎英雄归来！" << endl;
}

void welcome(int number) {  // 👈 期望接收一个整数
    cout << "欢迎访客编号：" << number << endl;
}

int main() {
    welcome(NULL);    // 🎲 危险！编译器可能会调用错误的函数
                         // 因为 NULL 实际上是整数 0
    return0;
}

// 🎯 现代 C++ 的优雅写法
int* ptr = nullptr;   // ✨ 类型安全，意图明确

// 🔍 函数重载场景
void process(int i) { /* ... */ }     // 处理整数
void process(int* p) { /* ... */ }    // 处理指针

// 🎮 使用示例
process(nullptr);     // ✅ 完美匹配指针版本
process(NULL);        // ❌ 避免使用，可能产生歧义
process(0);          // ❌ 更不应该这样做

// 🛡️ 安全的指针检查
if (ptr == nullptr) {
    // 🎯 代码意图清晰，无歧义
    std::cout << "指针未初始化" << std::endl;
}

// 🎯 nullptr 具有神奇的类型转换能力
void* ptr = nullptr;   // ✨ 通用指针类型
int* iptr = nullptr;   // 🔄 自动转换为 int 指针
char* cptr = nullptr;  // 📝 自动转换为 char 指针
double* dptr = nullptr; // 💫 自动转换为 double 指针

// 🔍 重载函数示例
void process(int i) { cout << "🔢 整数处理路径" << endl; }
void process(int* p) { cout << "👉 指针处理路径" << endl; }

process(nullptr);  // ✅ 编译器智能匹配指针版本
process(0);       // ⚠️ 匹配整数版本

// 🔍 指针检查更加直观
if (ptr == nullptr) {          // ✨ 代码意图一目了然
cout << "⚠️ 空指针检测" << endl;
}

// 🎯 链式判断也很优雅
if (ptr1 == nullptr && ptr2 == nullptr) {
cout << "📢 多指针空值检测" << endl;
}

// 🔍 nullptr 的类型声明
const std::nullptr_t null_value = nullptr;  // nullptr_t 是 nullptr 的实际类型
                                           // 这是 NULL(0) 所不具备的特性！

// 对比传统 NULL
#define NULL 0    // ❌ NULL 仅仅是个宏定义的整数
                 // 这就是为什么它会带来类型安全问题

// ✅ 合法的转换
void* ptr1 = nullptr;        // 👍 可以转换为任意指针类型
char* ptr2 = nullptr;        // 👍 完美转换
MyClass* ptr3 = nullptr;     // 👍 类指针也没问题

// ❌ 非法的转换
int num = nullptr;           // 🚫 编译错误！不能转换为整数
float f = nullptr;           // 🚫 编译错误！不能转换为浮点数
char c = nullptr;           // 🚫 编译错误！不能转换为字符

// 对比 NULL 的问题
int x = NULL;               // ⚠️ 这居然可以编译通过！因为 NULL 就是 0

// 🎯 布尔转换示例
bool test1 = nullptr;        // ✅ 结果为 false
if (nullptr) { }            // 永远不会执行
bool test2 = ptr == nullptr; // ✅ 正确的指针判空方式

// 💡 更安全的条件判断
void* ptr = nullptr;
if (!ptr) {                 // 👍 简洁的写法
    std::cout << "指针为空" << std::endl;
}

if (ptr == nullptr) {       // 👍 更明确的写法
    std::cout << "指针为空" << std::endl;
}

// 🎨 通用的指针检查模板
template<typename T>
bool isNullPtr(T* ptr) {
    return ptr == nullptr;    // ✨ 对任何指针类型都有效
}

// 🎯 使用示例
class MyClass {};
MyClass* obj = nullptr;
if (isNullPtr(obj)) {        // 完美运行！
    std::cout << "对象指针为空" << std::endl;
}

// 🎭 重载函数示例
void process(int value) {
    std::cout << "处理整数：" << value << std::endl;
}

void process(int* ptr) {
    std::cout << "处理指针" << std::endl;
}

// ✨ 使用对比
process(nullptr);    // ✅ 明确调用指针版本
process(NULL);       // ⚠️ 可能产生歧义！编译器可能选择整数版本
process(0);         // ❌ 调用整数版本

// 🚀 与智能指针协同
std::unique_ptr<int> uptr = nullptr;  // ✨ 创建空的智能指针
std::shared_ptr<double> sptr;         // ✨ 默认初始化为 nullptr

// 🔍 智能指针判空
if (!uptr) {  // 等同于 if (uptr == nullptr)
    cout << "unique_ptr 为空" << endl;
}

// 🎯 重置智能指针
sptr.reset(nullptr);  // ✨ 显式重置为空

// 🎭 避免在条件表达式中的歧义
int* ptr = nullptr;
if (ptr)        // ✅ 推荐：直接判断
if (ptr != nullptr)  // ✅ 也可以：显式判断
if (!ptr)      // ✅ 推荐：判断空指针

// ⚠️ 需要注意的情况
void* vptr = nullptr;
int* iptr = static_cast<int*>(vptr);  // ✅ 正确的类型转换

// 🚫 避免这样的隐式转换
long value = reinterpret_cast<long>(nullptr);  // ❌ 不推荐

// 🌟 跨平台一致性
#ifdef _WIN64
    // Windows 64位系统
    static_assert(sizeof(nullptr) == 8, "nullptr size error");
#else
    // 其他平台
    static_assert(sizeof(nullptr) == sizeof(void*), "nullptr size error");
#endif

// 🔄 平台无关的指针操作
template<typename T>
bool isValidPointer(T* ptr) {
    return ptr != nullptr;  // ✨ 在所有平台上行为一致
}

// 🛡️ [[nodiscard]] 确保返回值不会被忽略
[[nodiscard]] bool isPointerValid(void* ptr) {
    return ptr != nullptr;
}

// ✨ 使用示例
void example() {
    int* ptr = nullptr;
    
    isPointerValid(ptr);    // ⚠️ 编译警告：返回值被忽略
    
    if (isPointerValid(ptr)) {  // ✅ 正确使用方式
        // 处理有效指针
    }
}

// 🎯 另一个实用示例
class Resource {
    [[nodiscard]] static Resource* create() {
        returnnew Resource();
    }
};

void usage() {
    Resource::create();  // ⚠️ 编译警告：资源泄漏风险！
    
    // ✅ 正确用法：
    Resource* res = Resource::create();  // 保存返回值
}

// 🚀 编译器优化示例
int* ptr = nullptr;
if (ptr == nullptr) {  // ✨ 会被优化,没有运行时开销
    // 处理空指针情况
}