【UE 悬挂指针】C++传统指针，智能指针，以及UE的IsValid函数的原理

海码007

已于 2024-08-10 12:11:20 修改

阅读量841

点赞数 12

分类专栏： UE 文章标签： c++ 开发语言 UE

于 2024-08-02 10:02:30 首次发布

本文链接：https://blog.csdn.net/hhw_hhw/article/details/140864067

版权

UE 专栏收录该内容

42 篇文章 46 订阅

订阅专栏

请添加图片描述

🙋‍♂️ 作者：海码007
📜 专栏：UE虚幻引擎专栏
💥 标题：【UE 悬挂指针】C++传统指针，智能指针，以及UE的IsValid函数的原理
❣️ 寄语：书到用时方恨少，事非经过不知难！
🎈 最后：文章作者技术和水平有限，如果文中出现错误，希望大家能指正，同时有问题的话，欢迎大家留言讨论。

0 引言

最近在项目中遇到一些指针的坑，今天再回过头来总结一遍。主要包括几个方面，一个是 C++ 传统指针无法判断指针指向内存是否被销毁，然后可以通过 智能指针 的方式进行解决。再一个是 UE4 中的所有继承自 UObject 对象的指针都可以使用 IsValid 函数判断指向的内存是否有效，这个是 C++ 传统指针所没有的。

1 C++传统的指针

1.1 悬挂指针问题

在项目中其实很容易出现悬挂指针的问题。下面演示一个最简单的代码

#include <iostream>
using namespace std;

int main()
{
    int* p1 = new int(3);
    int* p2 = p1;
    delete p1;
    if (p2 == nullptr)
    {
        cout << "p2 is nullptr" << endl;
    }
    else
    {
        cout << "p2 is not nullptr" << endl;
    }

    if (p1 == nullptr)
    {
        cout << "p1 is nullptr" << endl;
    }
    else
    {
        cout << "p1 is not nullptr" << endl;
    }
}

输出结果：在这里插入图片描述

此时指针变量都还保存着目标位置的地址，但是此时该地址的内存已经被释放了，就导致悬挂指针的问题。此时p1和p2保存的值不为nullptr，所以访问变量时程序会直接崩溃。

1.2 C++如何解决悬挂指针问题

悬挂指针问题，C++没有提供方法来检测指针当前指向的内存区域是否有效。所以只能通过别的办法解决。

在C++中，悬挂指针（Dangling Pointer）是指向已被释放或无效内存的指针。访问悬挂指针会导致未定义行为，可能引发程序崩溃或其他严重问题。解决悬挂指针问题是编写健壮和安全代码的重要部分。以下是一些常见的方法来解决悬挂指针问题：

1.2.1 使用智能指针

智能指针是C++标准库提供的一种工具，用于自动管理动态内存的生命周期。常见的智能指针包括std::unique_ptr、std::shared_ptr和std::weak_ptr。

std::unique_ptr：独占所有权，确保一个对象只有一个所有者。
std::shared_ptr：共享所有权，多个指针可以共享同一个对象，引用计数自动管理对象的生命周期。
std::weak_ptr：与std::shared_ptr配合使用，解决循环引用问题，不影响引用计数。

#include <memory>

void UseSmartPointers()
{
    // 使用 unique_ptr
    std::unique_ptr<int> uniquePtr = std::make_unique<int>(42);

    // 使用 shared_ptr
    std::shared_ptr<int> sharedPtr1 = std::make_shared<int>(42);
    std::shared_ptr<int> sharedPtr2 = sharedPtr1; // 共享所有权

    // 使用 weak_ptr
    std::weak_ptr<int> weakPtr = sharedPtr1;

    if (auto lockedPtr = weakPtr.lock())
    {
        // weak_ptr 转换为 shared_ptr 成功，表示对象仍然有效
        int value = *lockedPtr;
    }
    else
    {
        // 对象已被销毁
    }
}

1.2.2 手动管理指针

如果必须使用原生指针，可以通过手动管理指针来避免悬挂指针问题。这包括在释放内存后将指针设置为nullptr，并在使用指针前检查其是否为nullptr。（这种情况还得保证没有把指针赋值给别的指针）

void ManualPointerManagement()
{
    int* ptr = new int(42);

    // 使用指针
    if (ptr)
    {
        int value = *ptr;
    }

    // 释放内存并将指针设置为 nullptr
    delete ptr;
    ptr = nullptr;

    // 再次使用指针前检查是否为 nullptr
    if (ptr)
    {
        int value = *ptr;
    }
}

1.2.3 使用RAII（资源获取即初始化）

RAII是一种C++编程惯用法，通过对象的生命周期来管理资源。构造函数获取资源，析构函数释放资源。智能指针就是RAII的一个例子。

class Resource
{
public:
    Resource() { /* 获取资源 */ }
    ~Resource() { /* 释放资源 */ }
};

void UseRAII()
{
    Resource res; // 在作用域结束时自动释放资源
}

1.2.4 使用容器类

使用标准库容器（如std::vector、std::list等）来管理动态分配的对象。容器会自动管理对象的生命周期，避免悬挂指针问题。

#include <vector>

void UseContainers()
{
    std::vector<int> vec;
    vec.push_back(42);

    // 使用容器中的元素
    int value = vec[0];
}

1.2.5 避免裸指针传递

尽量避免在函数接口中传递裸指针，最上面演示的示例就是直接裸指针赋值，导致悬挂指针。

void ProcessData(std::shared_ptr<int> data)
{
    if (data)
    {
        int value = *data;
    }
}

void UseSmartPointerInFunction()
{
    std::shared_ptr<int> data = std::make_shared<int>(42);
    ProcessData(data);
}

2 UE中是如何管理指针的

在Unreal Engine 4（UE4）中，避免指针内存泄漏问题是通过多种机制和工具来实现的。以下是一些关键的机制和工具：

2.1 智能指针

UE4提供了多种智能指针类型，用于自动管理对象的生命周期，避免内存泄漏。

TSharedPtr：类似于标准库的std::shared_ptr，用于共享所有权的智能指针。
TWeakPtr：类似于标准库的std::weak_ptr，用于解决循环引用问题。
TUniquePtr：类似于标准库的std::unique_ptr，用于独占所有权的智能指针。

#include "Templates/SharedPointer.h"

void UseSmartPointers()
{
    // 使用 TSharedPtr
    TSharedPtr<int> SharedPtr1 = MakeShared<int>(42);
    TSharedPtr<int> SharedPtr2 = SharedPtr1; // 共享所有权

    // 使用 TWeakPtr
    TWeakPtr<int> WeakPtr = SharedPtr1;

    if (TSharedPtr<int> LockedPtr = WeakPtr.Pin())
    {
        // WeakPtr 转换为 SharedPtr 成功，表示对象仍然有效
        int Value = *LockedPtr;
    }
    else
    {
        // 对象已被销毁
    }

    // 使用 TUniquePtr
    TUniquePtr<int> UniquePtr = MakeUnique<int>(42);
}

2.2 垃圾回收机制

UE4的垃圾回收机制是专门为UObject及其派生类设计的。所有继承自UObject的对象都由UE4的垃圾回收系统管理，这大大减少了内存泄漏的风险。

UObject：所有继承自UObject的类都参与垃圾回收。
引用计数：UE4使用引用计数来跟踪对象的引用，当引用计数为零时，对象会被标记为待销毁。
标记-清除算法：垃圾回收器使用标记-清除算法来识别和销毁不再使用的对象。

void UseUObject()
{
    // 创建一个 UObject 派生类实例
    UObject* MyObject = NewObject<UObject>();

    // 使用 MyObject
    if (IsValid(MyObject))
    {
        // 对象仍然有效
    }

    // MyObject 会在适当的时候被垃圾回收器销毁
}

2.2.1 `IsValid`函数

IsValid函数通常用于检查一个UObject指针是否有效，即指针是否指向一个未被销毁的对象。IsValid函数的原理涉及到UE4的对象管理和垃圾回收机制。

2.2.1.1 使用示例代码

UObject* MyObject = GetSomeUObject();

if (IsValid(MyObject))
{
    // MyObject 是有效的，可以安全地使用
}
else
{
    // MyObject 是无效的，不能使用
}

2.2.1.2 `IsValid`函数的原理

IsValid函数的实现依赖于UE4的对象管理系统，特别是UObject的生命周期管理。以下是IsValid函数的工作原理：

检查指针是否为空：首先，IsValid函数会检查传入的指针是否为空。如果指针为空，则返回false。
检查对象的有效性标志：如果指针不为空，IsValid函数会进一步检查对象的内部状态。具体来说，它会检查对象的InternalFlags，以确定对象是否已被标记为待销毁。
检查对象是否正在被垃圾回收：IsValid函数还会检查对象是否正在被垃圾回收系统处理。如果对象正在被销毁或已经被销毁，IsValid函数会返回false。

以下是IsValid函数的一个简化实现，展示了其基本工作原理：

#include "UObject/UObjectGlobals.h"

bool IsValid(const UObject* Object)
{
    // 检查指针是否为空
    if (Object == nullptr)
    {
        return false;
    }

    // 检查对象是否已被标记为待销毁
    if (Object->IsPendingKill())
    {
        return false;
    }

    // 检查对象是否正在被垃圾回收
    if (Object->HasAnyFlags(RF_BeginDestroyed) || Object->HasAnyFlags(RF_FinishDestroyed))
    {
        return false;
    }

    return true;
}

2.3 引用管理

UE4提供了多种引用管理工具，帮助开发者更好地管理对象的生命周期。

TWeakObjectPtr：用于弱引用UObject，避免悬挂指针问题。
TSoftObjectPtr：用于软引用UObject，可以在对象被卸载时自动处理引用。
FScopedPointer：用于在作用域结束时自动销毁对象。

#include "UObject/WeakObjectPtr.h"
#include "UObject/SoftObjectPtr.h"

void UseReferenceManagement()
{
    // 使用 TWeakObjectPtr
    TWeakObjectPtr<UObject> WeakObjectPtr = MyObject;

    if (WeakObjectPtr.IsValid())
    {
        // 对象仍然有效
    }

    // 使用 TSoftObjectPtr
    TSoftObjectPtr<UObject> SoftObjectPtr = MyObject;

    if (SoftObjectPtr.IsValid())
    {
        // 对象仍然有效
    }
}

2.4 自动化工具

UE4提供了一些自动化工具和调试功能，帮助开发者检测和解决内存泄漏问题。

内存分析器：UE4的内存分析器可以帮助开发者检测内存使用情况，识别潜在的内存泄漏。
调试工具：UE4提供了多种调试工具，如Stat命令和MemReport命令，帮助开发者监控内存使用情况。

// 在控制台中使用 Stat 命令
Stat Memory

// 在控制台中使用 MemReport 命令
MemReport

2.5 避免循环引用

循环引用是内存泄漏的常见原因之一。使用TWeakPtr或TWeakObjectPtr可以有效避免循环引用问题。

#include "Templates/SharedPointer.h"

class B; // 前向声明

class A
{
public:
    TSharedPtr<B> PtrToB;
};

class B
{
public:
    TWeakPtr<A> PtrToA; // 使用弱指针避免循环引用
};

void AvoidCircularReference()
{
    TSharedPtr<A> APtr = MakeShared<A>();
    TSharedPtr<B> BPtr = MakeShared<B>();

    APtr->PtrToB = BPtr;
    BPtr->PtrToA = APtr; // 使用弱指针避免循环引用
}

2.6 使用`TArray`和其他容器类

UE4的容器类（如TArray、TMap、TSet等）可以自动管理对象的生命周期，避免内存泄漏。

示例代码

#include "Containers/Array.h"

void UseContainers()
{
    TArray<int32> IntArray;
    IntArray.Add(42);

    // 使用 IntArray 中的元素
    int32 Value = IntArray[0];
}

2.7 避免不必要的动态分配

尽量避免不必要的动态内存分配，使用栈内存或局部变量来管理对象的生命周期。

示例代码

void AvoidDynamicAllocation()
{
    int32 StackVariable = 42; // 使用栈内存
    int32* DynamicVariable = new int32(42); // 动态分配内存

    // 使用 StackVariable
    int32 Value1 = StackVariable;

    // 使用 DynamicVariable
    int32 Value2 = *DynamicVariable;

    // 释放动态分配的内存
    delete DynamicVariable;
}