《OGRE 3D 渲染引擎原理与架构》13.2 SharedPtr 智能指针

OGRE 的 SharedPtr 在 v14 里是 std::shared_ptr 的子类,仅作向后兼容:旧的 bind/useCount/getPointer/isNull/setNull 映射到 reset/use_count/get/operator bool。它可隐式转成 std::shared_ptr,static_pointer_cast/dynamic_pointer_cast 直接沿用标准库。lab 用 C++ 复现这个包装子类与旧 API 映射。

13.2 SharedPtr 智能指针

老版本 OGRE 的资源句柄(MeshPtr、MaterialPtr……)都是自研的 SharedPtr。到了 v14,它直接继承 std::shared_ptr——这不是自研引用计数,而是标准库的薄包装。这一节看这个兼容层的结构。

本章与站内既有内容的分工

13.1 讲原始内存分配;这里讲对象生命周期的管理。重点是一个「从自研智能指针到标准库」的真实演进案例。

SharedPtr 继承 std::shared_ptr

OgreSharedPtr.h 里的定义很短——就是一个带旧 API 的 std::shared_ptr 子类:

// OgreMain/include/OgreSharedPtr.h:class SharedPtr(v14.6.3 源码摘录,已删减)
    /// @deprecated for backwards compatibility only, rather use shared_ptr directly
    template<class T> class SharedPtr : public shared_ptr<T>
    {
    public:
        SharedPtr(std::nullptr_t) {}
        SharedPtr() {}
        template< class Y>
        explicit SharedPtr(Y* ptr) : shared_ptr<T>(ptr) {}
        template< class Y, class Deleter >
        SharedPtr( Y* ptr, Deleter d ) : shared_ptr<T>(ptr, d) {}
        SharedPtr(const SharedPtr& r) : shared_ptr<T>(r) {}
        template<class Y>
        SharedPtr(const SharedPtr<Y>& r) : shared_ptr<T>(r) {}

        // implicit conversion from and to shared_ptr
        template<class Y>
        SharedPtr(const shared_ptr<Y>& r) : shared_ptr<T>(r) {}
        operator const shared_ptr<T>&() { return static_cast<shared_ptr<T>&>(*this); }

第一行注释就标了 @deprecated:「仅为向后兼容,直接使用 shared_ptr」。引用计数、析构、线程安全全来自 std::shared_ptr。两个隐式转换保证新老代码互通:

  • 从 shared_ptr<Y> 构造(老代码接收标准库句柄);
  • operator const shared_ptr<T>&()(标准库代码直接接收 SharedPtr)。

旧 API 映射表

类里保留了一批 OGRE_DEPRECATED 的旧方法,逐一映射到标准库:

// OgreMain/include/OgreSharedPtr.h:旧 API(v14.6.3 源码摘录,已删减)
        /// @deprecated use Ogre::static_pointer_cast instead
        template<typename Y>
        OGRE_DEPRECATED SharedPtr<Y> staticCast() const { return static_pointer_cast<Y>(*this); }
        /// @deprecated use Ogre::dynamic_pointer_cast instead
        template<typename Y>
        OGRE_DEPRECATED SharedPtr<Y> dynamicCast() const { return dynamic_pointer_cast<Y>(*this); }
        /// @deprecated this api will be dropped. use reset(T*) instead
        OGRE_DEPRECATED void bind(T* rep) { shared_ptr<T>::reset(rep); }
        /// @deprecated use use_count() instead
        OGRE_DEPRECATED unsigned int useCount() const { return shared_ptr<T>::use_count(); }
        /// @deprecated use get() instead
        OGRE_DEPRECATED T* getPointer() const { return shared_ptr<T>::get(); }
        /// @deprecated use SharedPtr::operator bool instead
        OGRE_DEPRECATED bool isNull(void) const { return !shared_ptr<T>::operator bool(); }
        /// @deprecated use reset() instead
        OGRE_DEPRECATED void setNull() { shared_ptr<T>::reset(); }
旧 API新写法
bind(T*)reset(T*)
useCount()use_count()
getPointer()get()
isNull()operator bool
setNull()reset()
staticCast<Y>() / dynamicCast<Y>()static_pointer_cast / dynamic_pointer_cast

头文件里还 using std::static_pointer_cast; using std::dynamic_pointer_cast;——把标准库自由函数引入 Ogre 命名空间。这是个值得注意的演进策略:不重写引用计数,而是让旧名字逐渐对齐标准库,代码库自然迁移。

引用寿命与可用状态是两条线

SharedPtr 可以延长对象寿命,Resource 的加载状态仍可变化。资源被卸载后仍可能有引用,队列捕获的强引用也可能晚于场景对象释放。

退出验收同时检查引用释放顺序和资源状态。原生场景在卸载前销毁实体、处理捕获 Mesh 的回调并移除监听器。

源码定位

上游引用固定到 OGRE v14.6.3 源码 。

可运行产物:C++ 最小验证

下面复现 SharedPtr 包装子类与旧 API 映射。它与 src/13-2-shared-ptr.cpp 逐字节一致:

// file: src/13-2-shared-ptr.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/13-2-shared-ptr.cpp -o bin/13-2-shared-ptr && ./bin/13-2-shared-ptr
//
// 复现 Ogre::SharedPtr:std::shared_ptr 的子类(向后兼容包装):
//   v14 的 SharedPtr<T> : public shared_ptr<T>,可隐式转为 shared_ptr<T>;
//   保留旧 API:bind/reset、useCount/use_count、getPointer/get、isNull、setNull;
//   static_pointer_cast 仍是标准自由函数。
//   (对应 OgreSharedPtr.h)
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <memory>
#include <string>

namespace ogre_repro {

// 对应 Ogre::SharedPtr:std::shared_ptr 的子类(deprecated 向后兼容)
template <class T>
class SharedPtr : public std::shared_ptr<T> {
 public:
  SharedPtr() {}
  SharedPtr(T* ptr) : std::shared_ptr<T>(ptr) {}
  SharedPtr(const std::shared_ptr<T>& r) : std::shared_ptr<T>(r) {}

  // 对应旧 API bind → reset
  void bind(T* rep) { this->reset(rep); }
  // 对应 useCount → use_count
  long useCount() const { return this->use_count(); }
  // 对应 getPointer → get
  T* getPointer() const { return this->get(); }
  // 对应 isNull → operator bool
  bool isNull() const { return !std::shared_ptr<T>::operator bool(); }
  // 对应 setNull → reset
  void setNull() { this->reset(); }
};

struct Mesh {
  std::string name;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  SharedPtr<Mesh> m1(new Mesh{"Robot"});
  CHECK(!m1.isNull());
  CHECK(m1.getPointer()->name == "Robot");

  // 复制:引用计数增加
  SharedPtr<Mesh> m2 = m1;
  CHECK(m1.useCount() == 2);

  // 隐式转为 std::shared_ptr
  std::shared_ptr<Mesh> stdPtr = m1;
  CHECK(stdPtr.use_count() == 3);

  // static_pointer_cast 派生类 → 基类(简化用同类型)
  SharedPtr<Mesh> m3 = std::static_pointer_cast<Mesh>(m1);
  CHECK(m3.get() == m1.get());
  CHECK(m1.useCount() == 4);

  // setNull 释放一份引用
  m2.setNull();
  CHECK(m2.isNull());
  CHECK(m1.useCount() == 3);

  // 旧 API bind:绑定新对象,不改变 m1
  m2.bind(new Mesh{"Weapon"});
  CHECK(!m2.isNull());
  CHECK(m2.getPointer()->name == "Weapon");
  CHECK(m1.getPointer()->name == "Robot");

  return lab::report("13-2 内存与容器:SharedPtr 智能指针");
}

本机实测(Apple clang 16,clang++ -std=c++20):编译通过(-Wall 零警告),断言 11/11 通过。

小结

  • v14 的 SharedPtr<T> : public shared_ptr<T>,引用计数完全来自标准库。
  • 隐式转换双向打通:老代码接标准库句柄,标准库代码直接收 SharedPtr。
  • 旧 API(bind/useCount/getPointer/isNull/setNull)逐一映射到 reset/use_count/get/operator bool/reset。
  • 演进策略:不重写智能指针,用兼容层让代码自然迁移到标准库。

阅读导航:上一节:13.1 对齐内存分配器 · 下一节:13.3 分类分配与容器策略 。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图