首页 > 编程语言 > 详细

【UE4 C++ 基础知识】<15> 智能指针 TSharedPtr、UniquePtr、TWeakPtr、TSharedRef

时间：2021-05-04 23:37:28      阅读：158      评论：0      收藏：0      [点我收藏+]

基本概念

  • UE4 对 UObject 对象提供垃圾回收
  • UE4 对原生对象不提供垃圾回收，需要手动进行清理
    • 方式
      • malloc / free
      • new / delete
    • 缺点
      • 如果不及时清理，则会占用内存，或者导致内存泄漏
      • 如果不小心提前清理，则会导致野指针
  • UE4 提供共享指针库来管理内存，它是C++11智能指针的自定义实现
    • 分类
      • TSharedPtr
      • UniquePtr
      • TWeakPtr
      • TSharedRef
    • 优点
      • 防止内存泄漏 共享引用不存在时，智能指针（弱指针除外）会自动删除对象。
      • 弱引用 弱指针会中断引用循环并阻止悬挂指针。
      • 可选择的线程安全 虚幻智能指针库包括线程安全代码，可跨线程管理引用计数。如无需线程安全，可用其换取更好性能。
      • 运行时安全 共享引用从不为空，可固定随时取消引用。
      • 授予意图 可轻松区分对象所有者和观察者。
      • 内存 智能指针在64位下仅为C++指针大小的两倍（加上共享的16字节引用控制器）。唯一指针除外，其与C++指针大小相同。

共享指针 TSharedPtr

  • TSharedPtr 不能指向 UObject。如果想要指向UObject，可以使用TWeakObjectPtr
  • TSharedPtr 可以对FStructures 使用

创建/初始化/ 重置

  • MakeShareable()/MakeShared<T>() 函数

  • Reset() 函数

    class SimpleObject {
public:
	SimpleObject() { UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"SimpleObject Construct")); }
	~SimpleObject() { UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"SimpleObject Destruct")); }
	void ExeFun() { UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"Execute")); }
};

    // 快速创建共享指针
TSharedPtr<SimpleObject> simObjectPtr(new SimpleObject());
// MakeShareable 创建共享指针
TSharedPtr<SimpleObject> simObjectPtr2 = MakeShareable(new SimpleObject());
// 创建线程安全
TSharedPtr<SimpleObject, ESPMode::ThreadSafe> simObjectPtr3 = MakeShareable(new SimpleObject());
// 查看引用计数

UE_LOG(LogTemp, Warning,
	TEXT(__FUNCTION__"引用计数: simObjectPtr[%d], simObjectPtr2[%d], simObjectPtr3[%d] "),
simObjectPtr.GetSharedReferenceCount(), simObjectPtr2.GetSharedReferenceCount(), simObjectPtr3.GetSharedReferenceCount());

// 重置共享指针
simObjectPtr.Reset();
simObjectPtr2 = nullptr;

    技术分享图片

复制/转移

  • 赋值

  • MoveTemp / MoveTempIfPossible

    // 复制共享指针
TSharedPtr<SimpleObject> simObjectPtr_copy = simObjectPtr;
UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"引用计数: simObjectPtr[%d], simObjectPtr_copy[%d],"),
	simObjectPtr.GetSharedReferenceCount(), simObjectPtr_copy.GetSharedReferenceCount());

// 转移共享指针
TSharedPtr<SimpleObject> simObjectPtr_MoveTemp = MoveTemp(simObjectPtr_copy);  // 另 MoveTempIfPossible()
UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"引用计数: simObjectPtr[%d], simObjectPtr_copy[%d], simObjectPtr_MoveTemp[%d]"),
	simObjectPtr.GetSharedReferenceCount(), simObjectPtr_copy.GetSharedReferenceCount(), simObjectPtr_MoveTemp.GetSharedReferenceCount()

    技术分享图片

条件判断 / 对比 / 解引用与访问

  • -> 运算符

  • Get() 函数

  • IsValid() 函数

  • == != 运算符

    if (simObjectPtr)					// 条件判断
{
	simObjectPtr->ExeFun();			// 解引用
}
if (simObjectPtr.Get() != nullptr)	// 条件判断
{
	simObjectPtr.Get()->ExeFun();	//解引用
}
if (simObjectPtr.IsValid())			// 条件判断
{
	(*simObjectPtr).ExeFun();		// 解引用
}
if (simObjectPtr == simObjectPtr_copy)	// 对比
{
	UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"simObjectPtr_copy == simObjectPtr"));
}

    技术分享图片

共享引用 TSharedRef

  • 共享引用不可为空
  • 不可用于 UObject对象
  • 没有 IsValid() 函数

创建/初始化

  • MakeShareable()/MakeShared<T>() 函数

    // 创建共享引用
TSharedRef<SimpleObject> objRef(new SimpleObject());
TSharedRef<SimpleObject> objRef2 = MakeShareable(new SimpleObject());
TSharedRef<SimpleObject> objRef3 = MakeShared<SimpleObject>();

TSharedRef 与 TSharedPtr转换

  • 隐式转化

  • ToSharedRef()

    // TSharedRef -> TSharedPtr
TSharedPtr<SimpleObject> objPtr = objRef;

// TSharedPtr -> TSharedRef
 objRef3= objPtr.ToSharedRef();

比较

  • 没有 IsValid() 函数

    // 共享指针比较
if (objRef == objRef3)
{
	UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"objRef == objRef3 , 引用计数：%d"), objPtr.GetSharedReferenceCount());
}

    技术分享图片

弱指针 TWeakPtr

  • 与TSharedPtr相比，不参与引用计数
  • 对象不存在共享指针时，TWeakPtr将自动失效
  • 使用时需要判断有效性

创建/初始化/转换/重置

  • 通过 TSharedPtr 创建

  • 通过 TSharedRef 创建

  • 运算符 = 赋值

  • IsValid() 函数判断有效性

  • Pin() 函数转成 TSharedPtr ,再解引用访问对象

  • Reset() 或 nullptr 重置

    // 强指针创建弱指针
TSharedPtr<SimpleObject> ObjPtr=MakeShared<SimpleObject>();
TWeakPtr<SimpleObject> ObjWeakPtr(ObjPtr);
UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"step1 引用计数：ObjPtr[%d]"), ObjPtr.GetSharedReferenceCount());

//强引用创建弱指针
TSharedRef<SimpleObject> objRef = MakeShareable(new SimpleObject());
TWeakPtr<SimpleObject> ObjWeakPtr2(objRef);

TWeakPtr<SimpleObject> ObjWeakPtr_Copy = ObjWeakPtr;
UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"step2 引用计数：ObjPtr[%d]"), ObjPtr.GetSharedReferenceCount());

// 判断有效性
if (ObjWeakPtr.IsValid())
{
	TSharedPtr<SimpleObject> ObjPtr2 = ObjWeakPtr.Pin();
	ObjPtr2->ExeFun();
}

// 清空强指针
ObjPtr.Reset();
TSharedPtr<SimpleObject> ObjPtr2 = ObjWeakPtr.Pin();
UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"step3 引用计数：ObjPtr[%d]"), ObjPtr.GetSharedReferenceCount());

// 判断有效性
if (!ObjPtr2)
{
	UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"弱指针已空 "));
}

// 重置
ObjWeakPtr.Reset();
ObjWeakPtr_Copy = nullptr;

    技术分享图片

唯一指针 TUniquePtr

  • TUniquePtr 指向的对象只能被唯一指向，因而 Unique指针不能赋值给其它指针
  • 不要为共享指针或共享引用引用的对象创建唯一指针

创建/初始化/判断/解引用/重置

  • MakeUnique()

  • IsValid()

  • -> 运算符

  • Get() 函数

  • Release() 释放并返回指针

  • Reset() 或 nullptr 重置

    // 创建唯一指针
	TUniquePtr<SimpleObject> ObjUniquePtr = MakeUnique<SimpleObject>();
	UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__" Validity: ObjUniquePtr[%d]"), ObjUniquePtr.IsValid());

	// 判断有效性
	if (ObjUniquePtr.IsValid()) 
	{
		ObjUniquePtr->ExeFun(); // 解引用
	}

	// 释放指针，移交
	TUniquePtr<SimpleObject> ObjUniquePtr2(ObjUniquePtr.Release());
	UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__" Validity: ObjUniquePtr[%d], ObjUniquePtr2[%d]"), ObjUniquePtr.IsValid(), ObjUniquePtr2.IsValid());

	// 重置
	ObjUniquePtr.Reset();		
	ObjUniquePtr2 = nullptr;

    技术分享图片

基类与派生类的智能转换

共享指针转换

  • 派生类转基类 隐式转换

  • 基类转派生类 StaticCastSharedPtr

  • 非常量转常量 ConstCastSharedPtr

    TSharedPtr<SimpleObject> simpleObj;
TSharedPtr<ComplexObject> complexObj = MakeShared<ComplexObject>();

// 派生类转基类
simpleObj = complexObj;
UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"simpleObj is %s"), simpleObj.IsValid() ? TEXT("Valid") : TEXT("Not Valid"));

// 基类转派生类
TSharedPtr<ComplexObject> complexObj2 = StaticCastSharedPtr<ComplexObject>(simpleObj);
UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"complexObj2 is %s"), complexObj2.IsValid() ? TEXT("Valid") : TEXT("Not Valid"));

// 常量指针转非常量指针

const TSharedPtr<SimpleObject> simpleObj_const(new SimpleObject());
TSharedPtr<SimpleObject> simpleObj_mutable = ConstCastSharedPtr<SimpleObject>(simpleObj_const);
UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__"simpleObj_mutable is %s"), simpleObj_mutable.IsValid() ? TEXT("Valid") : TEXT("Not Valid"));

技术分享图片

共享引用转换

  • 隐式转换
  • StaticCastSharedRef

// 创建唯一指针
TUniquePtr ObjUniquePtr = MakeUnique();
UE_LOG(LogTemp, Warning, TEXT(FUNCTION" Validity: ObjUniquePtr[%d]"), ObjUniquePtr.IsValid());

// 判断有效性
if (ObjUniquePtr.IsValid())
{
	ObjUniquePtr->ExeFun(); // 解引用
}

// 释放指针，移交
TUniquePtr<SimpleObject> ObjUniquePtr2(ObjUniquePtr.Release());
UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__" Validity: ObjUniquePtr[%d], ObjUniquePtr2[%d]"), ObjUniquePtr.IsValid(), ObjUniquePtr2.IsValid());

// 重置
ObjUniquePtr.Reset();
ObjUniquePtr2 = nullptr;
  • ConstStaticCastSharedRef

代码省略

助手类 TSharedFromThis

  • 自定义类继承 TSharedFromThis 模板类

  • TSharedFromThis 会保存一个弱指针

  • AsShared() 将裸指针转智共享引用，可再隐式转为共享指针

  • SharedThis(this) 会返回具备"this"类型的TSharedRef

  • 不要在构造函数中调用 AsShared 或 Shared，共享引用此时并未初始化，将导致崩溃或断言

    // 基类
class BaseClass :public TSharedFromThis<BaseClass>
{
public:
	BaseClass() { UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__)); }
	virtual ~BaseClass() { UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__)); }
	virtual void ExeFun() { 
		TSharedRef<BaseClass> ThisAsSharedRef = AsShared();
	}
};

// 派生类
class ChildClass :public BaseClass 
{
public:
	ChildClass() { UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__)); }
	virtual ~ChildClass() { UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__)); }
	virtual void ExeFun() override{
		 //AsShared()返回 TSharedRef<BaseClass>, 因而编译不通过
		//TSharedRef<ChildClass> AsSharedRef = AsShared(); 

		TSharedRef<ChildClass> AsSharedRef = SharedThis(this);
	}
};

    TSharedPtr<BaseClass> BaseClassPtr = MakeShared<BaseClass>();
UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__" 引用计数：BaseClassPtr[%d]"), BaseClassPtr.GetSharedReferenceCount());

BaseClass* tempPtr = BaseClassPtr.Get();
TSharedPtr<BaseClass> BaseClassPtr_Shared =tempPtr->AsShared();
UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__" 引用计数：BaseClassPtr[%d], BaseClassPtr_Shared[%d]"), 
	BaseClassPtr.GetSharedReferenceCount(), BaseClassPtr_Shared.GetSharedReferenceCount());

// 使用下面语句运行，程序死机
// TSharedPtr<BaseClass> BaseClassPtr_New = MakeShareable(tempPtr);

    技术分享图片

注意

  • 避免将数据作为 TSharedRef 或 TSharedPtr 参数传到函数，此操作将因取消引用和引用计数而产生开销。相反，建议将引用对象作为 const & 进行传递。
  • 共享指针与虚幻对象(UObject 及其衍生类)不兼容。引擎具有 UObject 管理的单独内存管理系统（对象处理文档），两个系统未互相重叠。

参考

【UE4 C++ 基础知识】<15> 智能指针 TSharedPtr、UniquePtr、TWeakPtr、TSharedRef

原文：https://www.cnblogs.com/shiroe/p/14729821.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！