QSharedPointer 类

模板 <typename T> class QSharedPointer

QSharedPointer 类包含对一个共享指针的强引用。 更多...

头文件 #include <QSharedPointer>
CMakefind_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmakeQT += core

注意： 本类中的所有函数都是可重入的。

公共函数

QSharedPointer()
QSharedPointer(X *ptr)
QSharedPointer(X *ptr, Deleter d)
QSharedPointer(std::nullptr_t)
QSharedPointer(std::nullptr_t, Deleter d)
QSharedPointer(const QWeakPointer &other)
QSharedPointer(QSharedPointer &&other)
QSharedPointer(const QSharedPointer &other)
QSharedPointer(QSharedPointer &&other)
~QSharedPointer()
voidclear()
QSharedPointerconstCast() const
T *data() const
QSharedPointerdynamicCast() const
T *get() const
boolisNull() const
QSharedPointerobjectCast() const
(since 6.7) boolowner_before(const QSharedPointer &other) const
(since 6.7) boolowner_before(const QWeakPointer &other) const
(since 6.7) boolowner_equal(const QSharedPointer &other) const
(since 6.7) boolowner_equal(const QWeakPointer &other) const
(since 6.7) size_towner_hash() const
voidreset()
voidreset(T *t)
voidreset(T *t, Deleter deleter)
QSharedPointerstaticCast() const
voidswap(QSharedPointer &other)
QWeakPointertoWeakRef() const
booloperator bool() const
booloperator!() const
T &operator*() const
T *operator->() const
QSharedPointer &operator=(const QSharedPointer<T> &other)
QSharedPointer &operator=(QSharedPointer<T> &&other)
QSharedPointer &operator=(const QWeakPointer<T> &other)
QSharedPointer &operator=(QSharedPointer<X> &&other)

静态公共成员

QSharedPointer<T>create(Args &&... args)
size_tqHash(const QSharedPointer<T> &key, size_t seed = 0)
QSharedPointerqSharedPointerCast(const QSharedPointer<T> &other)
QSharedPointerqSharedPointerCast(const QWeakPointer<T> &other)
QSharedPointerqSharedPointerConstCast(const QSharedPointer<T> &src)
QSharedPointerqSharedPointerConstCast(const QWeakPointer<T> &src)
QSharedPointerqSharedPointerDynamicCast(const QSharedPointer<T> &src)
QSharedPointerqSharedPointerDynamicCast(const QWeakPointer<T> &src)
QSharedPointerqSharedPointerObjectCast(const QSharedPointer<T> &src)
std::shared_ptr<X>qSharedPointerObjectCast(const std::shared_ptr<T> &src)
std::shared_ptr<X>qSharedPointerObjectCast(std::shared_ptr<T> &&src)
QSharedPointerqSharedPointerObjectCast(const QWeakPointer<T> &src)
std::shared_ptr<X>qobject_pointer_cast(const std::shared_ptr<T> &src)
std::shared_ptr<X>qobject_pointer_cast(std::shared_ptr<T> &&src)
booloperator!=(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
booloperator!=(const QSharedPointer<T> &ptr1, const X *ptr2)
booloperator!=(const T *ptr1, const QSharedPointer<X> &ptr2)
booloperator!=(const QSharedPointer<T> &lhs, std::nullptr_t)
booloperator!=(std::nullptr_t, const QSharedPointer<T> &rhs)
QDebugoperator<<(QDebug debug, const QSharedPointer<T> &ptr)
booloperator==(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
booloperator==(const QSharedPointer<T> &ptr1, const X *ptr2)
booloperator==(const T *ptr1, const QSharedPointer<X> &ptr2)
booloperator==(const QSharedPointer<T> &lhs, std::nullptr_t)
booloperator==(std::nullptr_t, const QSharedPointer<T> &rhs)

详细描述

QSharedPointer是C++中的自动共享指针。它在不考虑const属性时与普通指针行为完全相同。

只要没有其他QSharedPointer对象引用它，QSharedPointer会在它的作用域结束时删除所持有的指针。

可以从普通指针、另一个QSharedPointer对象或提升QWeakPointer对象到强引用来创建QSharedPointer对象。

线程安全性

QSharedPointer 和 QWeakPointer 是可重入的类。这意味着，一般情况下，没有同步的 QSharedPointer 或 QWeakPointer 对象 不能 同时被多个线程访问。

不同的 QSharedPointer 和 QWeakPointer 对象可以安全地同时被多个线程访问。这包括它们指向相同对象的情况；引用计数机制是原子的，无需手动同步。

需要注意的是，虽然可以通过这种方式（即同时由多个线程访问，无需同步）访问指针值，但 QSharedPointer 和 QWeakPointer 对所指向的对象不提供任何保证。该对象的具体线程安全和可重入规则仍然适用。

其他指针类

Qt 还提供了另外两个指针包装类：QPointer 和 QSharedDataPointer。它们互不兼容，因为每个类都有其独特的用途。

QSharedPointer 通过外部引用计数（即在对象外部放置一个引用计数器）来持有一个共享指针。正如其名称所暗示的那样，指针值在所有 QSharedPointer 和 QWeakPointer 实例之间共享。然而，不应将指向的指针对象的内 容视为共享的：只有一个对象。因此，QSharedPointer 不提供分离或复制指向对象的方法。

QSharedDataPointer 的另一方面，它持有指向共享数据的指针（即从 QSharedData 派生的类）。它是通过在 QSharedData 基类中放置内部引用计数来实现的。因此，该类可以根据对受保护数据的访问类型进行分离：如果是非 const 访问，则会创建一个原子复制以完成操作。

QExplicitlySharedDataPointer 是 QSharedDataPointer 的一个变体，只是它只能在显式调用QExplicitlySharedDataPointer::detach() 时分离（因此得名）。

QScopedPointer 仅持有堆分配对象的指针，并在其析构函数中删除它。当需要堆分配并删除对象，但不再需要时，此类非常有用。QScopedPointer 是轻量级的，它不使用额外的结构或引用计数。

最后，QPointer 持有一个指向 QObject 派生对象的指针，但它是弱引用。与 QWeakPointer 具有相同的功能，但它的使用已被弃用。

可选指针跟踪

在编译时可以启用以进行调试目的的 QSharedPointer 的一个特性是一个指针跟踪机制。启用后，QSharedPointer 在全局集中注册其跟踪的所有指针。这允许捕获将同一个指针赋给两个 QSharedPointer 对象等错误。

此功能通过在包含 QSharedPointer 头文件之前定义宏 QT_SHAREDPOINTER_TRACK_POINTERS 而启用。

即使在未启用该功能的代码中，也可以安全地使用此功能。QSharedPointer 将确保即使在没有指针跟踪的代码中，也会从跟踪器中删除指针。

然而，需要注意的是，指针跟踪功能在对多继承或虚拟继承（即两个不同的指针地址可以引用同一对象）的支持上有局限性。在这种情况下，如果将指针转换为不同类型且其值发生变化，QSharedPointer的指针跟踪机制可能无法检测到跟踪的对象是否相同。

另请参阅 QSharedDataPointer，QWeakPointer，QScopedPointer和QEnableSharedFromThis。

成员函数文档

[noexcept，自6.7以来] 模板 <typename X> bool QSharedPointer::owner_before(const QSharedPointer<X> &other) const

[noexcept，自6.7以来] 模板 <typename X> bool QSharedPointer::owner_before(const QWeakPointer<X> &other) const

当且仅当此智能指针在实现定义的基于所有者的顺序中先于other时返回真。该顺序是，如果两个智能指针都为空或都拥有相同的对象（即使它们的实际类型和指针不同），则认为它们是等效的。

此函数是在Qt 6.7中引入的。

另请参阅 owner_equal。

[noexcept，自6.7以来] 模板 <typename X> bool QSharedPointer::owner_equal(const QSharedPointer<X> &other) const

[noexcept，自6.7以来] 模板 <typename X> bool QSharedPointer::owner_equal(const QWeakPointer<X> &other) const

当且仅当此智能指针和other共享所有者时返回真。

此函数是在Qt 6.7中引入的。

另请参阅 owner_before和owner_hash。

[noexcept，自6.7以来] size_t QSharedPointer::owner_hash() const

为此智能指针对象返回一个基于所有者的哈希值。比较相等的智能指针（按照owner_equal）将具有相同的基于所有者的哈希值。

此函数是在Qt 6.7中引入的。

另请参阅 owner_equal。

QSharedPointer()

创建一个null QSharedPointer（对象持有对nullptr的引用）。

[显式] 模板 <typename X> QSharedPointer::QSharedPointer(X *ptr)

创建一个指向ptr的QSharedPointer。指针ptr现在由这个QSharedPointer管理，不应传递给另一个QSharedPointer对象，也不应在对象外部删除。

自Qt 5.8以来，当最后一个对this QSharedPointer的引用被销毁时，ptr将通过调用X的析构函数来删除（即使X与QSharedPointer的模板参数T不同）。以前，会调用T的析构函数。

模板 <typename X, typename Deleter> QSharedPointer::QSharedPointer(X *ptr, Deleter d)

创建一个指向ptr的QSharedPointer。指针ptr现在由这个QSharedPointer管理，不应传递给另一个QSharedPointer对象，也不应在对象外部删除。

删除器参数d指定了该对象的自定义删除器。在强引用计数降至0时，将调用自定义删除器，而不是删除运算符delete()。这在例如调用deleteLater()在QObject对象上时很有用。

    static void doDeleteLater(MyObject *obj)
    {
        obj->deleteLater();
    }

    void otherFunction()
    {
        QSharedPointer<MyObject> obj =
            QSharedPointer<MyObject>(new MyObject, doDeleteLater);

        // continue using obj
        obj.clear();    // calls obj->deleteLater();
    }

请注意，即使QSharedPointer模板参数T不相同，也会用类型X的指针调用自定义删除器函数。

也可以直接指定一个成员函数，如下所示

    QSharedPointer<MyObject> obj =
        QSharedPointer<MyObject>(new MyObject, &QObject::deleteLater);

另请参阅clear（）。

QSharedPointer::QSharedPointer(std::nullptr_t)

创建一个为空的QSharedPointer。这等价于QSharedPointer默认构造函数。

template <typename Deleter> QSharedPointer::QSharedPointer(std::nullptr_t, Deleter d)

创建一个为空的QSharedPointer。这等价于QSharedPointer默认构造函数。

删除器参数d指定了该对象的自定义删除器。当强引用计数降至0时，会调用自定义删除器，而不是删除运算符delete()。

QSharedPointer::QSharedPointer(const QWeakPointer<T> &other)

通过提升弱引用other成为强引用并共享其指针来创建一个QSharedPointer。

如果T是此类模板参数的派生类型，QSharedPointer将执行自动转换。否则，您将收到编译器错误。

另请参阅QWeakPointer::toStrongRef（）。

[noexcept] template <typename X> QSharedPointer::QSharedPointer(QSharedPointer<X> &&other)

移动构造一个QSharedPointer实例，使其指向other指向的同一对象。

只有当代码X*可以隐式转换为代码T*时，此构造函数才参与重载解决。

QSharedPointer::QSharedPointer(const QSharedPointer<T> &other)

创建一个共享其他指针的指针的QSharedPointer对象。

如果T是此类模板参数的派生类型，QSharedPointer将执行自动转换。否则，您将收到编译器错误。

[noexcept] QSharedPointer::QSharedPointer(QSharedPointer<T> &&other)

移动构造一个QSharedPointer实例，使其指向other指向的同一对象。

QSharedPointer::~QSharedPointer()

销毁此QSharedPointer对象。如果它是存储的指针的最后引用，则将删除指针。

void QSharedPointer::clear()

清除此QSharedPointer对象，删除它可能有的对指针的引用。如果这是最后一个引用，则将删除指针本身。

template <typename X> QSharedPointer<X> QSharedPointer::constCast() const

对此指针的类型执行const_cast到代码X并返回共享引用的QSharedPointer。此函数可用于向上和向下转换，但对于向上转换更有用。

另请参阅isNull() 和 qSharedPointerConstCast()。

[静态] 模板 <typename... Args> QSharedPointer<T> QSharedPointer::create(Args &&... args)

这是一个重载函数。

创建一个 QSharedPointer 对象并分配一个类型为 T 的新项。该 QSharedPointer 内部和对象是在一次内存分配中分配的，这有助于减少长时间运行的应用程序中的内存碎片。

此函数将尝试调用适用于类型 T 且可以接受所传递所有参数（args）的构造函数。参数将被完美转发。

T *QSharedPointer::data() const

返回此对象引用的指针的值。

注意：不要删除此函数返回的指针或将其传递给可能删除它的另一个函数，包括创建 QSharedPointer 或 QWeakPointer 对象。

模板 <typename X> QSharedPointer<X> QSharedPointer::dynamicCast() const

从此指针的类型到 X 执行动态类型转换并返回一个共享引用的 QSharedPointer。如果此函数用于向上转换，则 QSharedPointer 将执行 dynamic_cast，这意味着如果此 QSharedPointer 所指向的对象不是类型 X，则返回的对象将为 null。

注意：模板类型 X 必须与此对象的模板具有相同的 const 和 volatile 说明符，否则转换将失败。如果您需要删除这些说明符，请使用 constCast()。

另请参阅qSharedPointerDynamicCast()。

T *QSharedPointer::get() const

与 data() 相同。

此函数提供与 std::shared_ptr 的 API 兼容性。

bool QSharedPointer::isNull() const

如果此对象引用 nullptr，则返回 true。

模板 <typename X> QSharedPointer<X> QSharedPointer::objectCast() const

从此指针的类型到 X 执行 qobject_cast() 并返回一个共享引用的 QSharedPointer。如果此函数用于向上转换，则 QSharedPointer 将执行 qobject_cast，这意味着如果此 QSharedPointer 所指向的对象不是类型 X，则返回的对象将为 null。

注意：模板类型 X 必须与此对象的模板具有相同的 const 和 volatile 说明符，否则转换将失败。如果您需要删除这些说明符，请使用 constCast()。

另请参阅qSharedPointerObjectCast()。

void QSharedPointer::reset()

与 clear() 相同。为了与 std::shared_ptr 兼容。

void QSharedPointer::reset(T *t)

将此QSharedPointer对象重置为指向t。等效于

    QSharedPointer<T> other(t); this->swap(other);

template <typename Deleter> void QSharedPointer::reset(T *t, Deleter deleter)

将此QSharedPointer对象重置为指向t，并带有Deleter deleter。等效于

    QSharedPointer<T> other(t, deleter); this->swap(other);

template <typename X> QSharedPointer<X> QSharedPointer::staticCast() const

将此指针的类型静态转换为X，并返回一个共享引用的QSharedPointer。此函数可用于向上的和向下的转换，但更适用于向上转换。

注意：模板类型 X 必须与此对象的模板具有相同的 const 和 volatile 说明符，否则转换将失败。如果您需要删除这些说明符，请使用 constCast()。

另请参阅dynamicCast()、constCast()和qSharedPointerCast()。

[noexcept] void QSharedPointer::swap(QSharedPointer<T> &other)

与other交换此共享指针实例。此函数非常快，永远不会失败。

QWeakPointer<T> QSharedPointer::toWeakRef() const

返回一个共享指向由此对象引用的指针的弱引用对象。

另请参阅QWeakPointer::QWeakPointer。

bool QSharedPointer::operator bool() const

如果所包含的指针不是nullptr，则返回true。此函数适用于使用if-constructs的情况，如

    if (sharedptr) { ... }

另请参阅isNull。

bool QSharedPointer::operator!() const

如果此对象指向nullptr，则返回true。此函数适用于使用if-constructs的情况，如

    if (!sharedptr) { ... }

另请参阅isNull。

T & QSharedPointer::operator*() const

提供对共享指针成员的访问。

如果所包含的指针是nullptr，行为是未定义的。

另请参阅isNull。

T *QSharedPointer::operator->() const

提供对共享指针成员的访问。

如果所包含的指针是nullptr，行为是未定义的。

另请参阅isNull。

QSharedPointer<T> & QSharedPointer::operator=(const QSharedPointer<T> &other)

使此对象共享other的指针。当前指针引用被丢弃，如果是最后一个，则会删除指针。

如果T是这个类模板参数的派生类型，则QSharedPointer将执行自动转换。否则，您将得到编译器错误。

[noexcept] QSharedPointer<T> & QSharedPointer::operator=(QSharedPointer<T> &&other)

移动分配other到此QSharedPointer实例。

QSharedPointer<T> &QSharedPointer::operator=(const QWeakPointer<T> &other)

提升other到强引用，并使此对象共享它引用的指针的引用。当前指针引用被丢弃，如果它是最后的引用，指针将被删除。

如果T是这个类模板参数的派生类型，则QSharedPointer将执行自动转换。否则，您将得到编译器错误。

[noexcept] 模板 <typename X> QSharedPointer<T> &QSharedPointer::operator=(QSharedPointer<X> &&other)

移动分配other到此QSharedPointer实例。

此赋值运算符只有当 X* 可以隐式转换为 T* 时才参与重载解析。

相关非成员

[noexcept] 模板 <typename T> size_t qHash(const QSharedPointer<T> &key, size_t seed = 0)

返回 key 的哈希值，使用 seed 来初始化计算。

模板 <typename X, typename T> QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &other)

返回持有 other 的指针的共享指针，并将其转换为类型 X。类型 T 和 X 必须属于同一个层次结构，以便 static_cast 成功。

请注意，X 必须具有与 T 相同的cv限制符（const 和 volatile），否则代码将无法编译。请使用 qSharedPointerConstCast 来去除const属性。

另请参阅QSharedPointer::staticCast()，qSharedPointerDynamicCast 和 qSharedPointerConstCast。

模板 <typename X, typename T> QSharedPointer<X> qSharedPointerCast(const QWeakPointer<T> &other)

返回持有 other 的指针的共享指针，并将其转换为类型 X。类型 T 和 X 必须属于同一个层次结构，以便 static_cast 成功。

首先将 other 对象转换为强引用。如果转换失败（因为它指向的对象已经被删除），则此函数返回空的 QSharedPointer。

请注意，X 必须具有与 T 相同的cv限制符（const 和 volatile），否则代码将无法编译。请使用 qSharedPointerConstCast 来去除const属性。

另请参阅QWeakPointer::toStrongRef，qSharedPointerDynamicCast 和 qSharedPointerConstCast。

模板 <typename X, typename T> QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &src)

返回指向 src 保存的指针的共享指针，并将其强制转换为类型 X。类型 T 和 X 必须属于同一层次结构，以便 const_cast 成功。类型 T 和 X 之间的 const 和 volatile 差异将被忽略。

也见 QSharedPointer::constCast()，qSharedPointerCast() 和 qSharedPointerDynamicCast()。

模板 <typename X, typename T> QSharedPointer<X> qSharedPointerConstCast(const QWeakPointer<T> &src)

返回指向 src 保存的指针的共享指针，并将其强制转换为类型 X。类型 T 和 X 必须属于同一层次结构，以便 const_cast 成功。类型 T 和 X 之间的 const 和 volatile 差异将被忽略。

首先将 src 对象转换为强引用。如果转换失败（因为它指向的对象已经被删除），则该函数将返回一个空 QSharedPointer。

也见 QWeakPointer::toStrongRef，qSharedPointerCast 和 qSharedPointerDynamicCast()。

模板 <typename X, typename T> QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &src)

使用动态强制转换到类型 X 从 src 保存的指针中获取适当类型的内部指针。如果动态强制转换失败，则返回的对象将为空。

请注意，X 必须具有与 T 相同的cv限制符（const 和 volatile），否则代码将无法编译。请使用 qSharedPointerConstCast 来去除const属性。

也见 QSharedPointer::dynamicCast，qSharedPointerCast 和 qSharedPointerConstCast()。

模板 <typename X, typename T> QSharedPointer<X> qSharedPointerDynamicCast(const QWeakPointer<T> &src)

使用动态强制转换到类型 X 从 src 保存的指针中获取适当类型的内部指针。如果动态强制转换失败，则返回的对象将为空。

首先将 src 对象转换为强引用。如果转换失败（因为它指向的对象已经被删除），则此函数也将返回一个空 QSharedPointer。

请注意，X 必须具有与 T 相同的cv限制符（const 和 volatile），否则代码将无法编译。请使用 qSharedPointerConstCast 来去除const属性。

也见 QWeakPointer::toStrongRef，qSharedPointerCast 和 qSharedPointerConstCast()。

模板 <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &src)

qSharedPointerObjectCast 函数用于进行共享指针转换。

使用 qobject_cast() 强制转换为类型 X 从 src 保存的指针中获取适当类型的内部指针。如果强制转换失败，则返回的对象将为空。

请注意，X 必须具有与 T 相同的cv限制符（const 和 volatile），否则代码将无法编译。请使用 qSharedPointerConstCast 来去除const属性。

也见 QSharedPointer::objectCast，qSharedPointerCast 和 qSharedPointerConstCast()。

template <typename X, typename T> std::shared_ptr<X> qSharedPointerObjectCast(const std::shared_ptr<T>& src)

使用 qobject_cast() 强制转换为类型 X 从 src 保存的指针中获取适当类型的内部指针。如果强制转换失败，则返回的对象将为空。

请注意，X必须与T具有相同的cv-限定符（const和volatile），否则代码编译将失败。使用const_pointer_cast来移除const属性。

template <typename X, typename T> std::shared_ptr<X> qSharedPointerObjectCast(std::shared_ptr<T>&& src)

使用qobject_cast()将类型转为X以获取适当类型的内部指针，返回指向src所持指针的共享指针。

如果qobject_cast成功，函数返回有效的共享指针，并将src重置为null。如果qobject_cast失败，返回的对象将是null，且src不会被修改。

请注意，X必须与T具有相同的cv-限定符（const和volatile），否则代码编译将失败。使用const_pointer_cast来移除const属性。

template <typename X, typename T> std::shared_ptr<X> qSharedPointerObjectCast(const QWeakPointer<T>& src)

qSharedPointerObjectCast 函数用于进行共享指针转换。

使用 qobject_cast() 强制转换为类型 X 从 src 保存的指针中获取适当类型的内部指针。如果强制转换失败，则返回的对象将为空。

首先将 src 对象转换为强引用。如果转换失败（因为它指向的对象已经被删除），则此函数也将返回一个空 QSharedPointer。

请注意，X 必须具有与 T 相同的cv限制符（const 和 volatile），否则代码将无法编译。请使用 qSharedPointerConstCast 来去除const属性。

也见 QWeakPointer::toStrongRef，qSharedPointerCast 和 qSharedPointerConstCast()。

template <typename X, typename T> std::shared_ptr<X> qobject_pointer_cast(const std::shared_ptr<T>& src)

返回指向src所持指针的共享指针。

与qSharedPointerObjectCast相同。此函数提供以实现STL兼容性。

template <typename X, typename T> std::shared_ptr<X> qobject_pointer_cast(std::shared_ptr<T>&& src)

与qSharedPointerObjectCast相同。此函数提供以实现STL兼容性。

template <typename T, typename X> bool operator!=(const QSharedPointer<T>& ptr1, const QSharedPointer<X>& ptr2)

如果ptr1和ptr2引用不同的指针，则返回true。

如果ptr2的模板参数与ptr1的不同，QSharedPointer将尝试执行自动static_cast以确保被比较的指针相等。如果ptr2的模板参数不是ptr1的基类或派生类，您将得到编译器错误。

template <typename T, typename X> bool operator!=(const QSharedPointer<T>& ptr1, const X *ptr2)

如果ptr1和ptr2引用不同的指针，则返回true。

如果ptr2的类型与ptr1的不同，QSharedPointer将尝试执行自动static_cast以确保被比较的指针相等。如果ptr2的类型不是ptr1的基类或派生类，您将得到编译器错误。

template <typename T, typename X> bool operator!=(const T *ptr1, const QSharedPointer<X>& ptr2)

当指针 ptr1 不与由 ptr2 引用的指针相同时，返回 true。

如果 ptr2 的模板参数与 ptr1 的类型不同，QSharedPointer 将尝试进行自动 static_cast，以确保比较的指针是相等的。如果 ptr2 的模板参数不是 ptr1 的类型的基础或派生类型，则会出现编译器错误。

template <typename T> bool operator!=(const QSharedPointer<T> &lhs, std::nullptr_t)

如果 lhs 引用了一个有效的（即非空）指针，则返回 true。

另请参阅 QSharedPointer::isNull。

template <typename T> bool operator!=(std::nullptr_t, const QSharedPointer<T> &rhs)

如果 rhs 引用了一个有效的（即非空）指针，则返回 true。

另请参阅 QSharedPointer::isNull。

template <typename T> QDebug operator<<(QDebug debug, const QSharedPointer<T> &ptr)

将 ptr 追踪的指针写入调试对象 debug，用于调试目的。

另请参阅 调试技巧。

template <typename T, typename X> bool operator==(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)

如果 ptr1 和 ptr2 引用了相同的指针，则返回 true。

如果ptr2的模板参数与ptr1的不同，QSharedPointer将尝试执行自动static_cast以确保被比较的指针相等。如果ptr2的模板参数不是ptr1的基类或派生类，您将得到编译器错误。

template <typename T, typename X> bool operator==(const QSharedPointer<T> &ptr1, const X *ptr2)

如果 ptr1 和 ptr2 引用了相同的指针，则返回 true。

如果ptr2的类型与ptr1的不同，QSharedPointer将尝试执行自动static_cast以确保被比较的指针相等。如果ptr2的类型不是ptr1的基类或派生类，您将得到编译器错误。

template <typename T, typename X> bool operator==(const T *ptr1, const QSharedPointer<X> &ptr2)

如果指针 ptr1 与由 ptr2 引用的指针相同，则返回 true。

如果 ptr2 的模板参数与 ptr1 的类型不同，QSharedPointer 将尝试进行自动 static_cast，以确保比较的指针是相等的。如果 ptr2 的模板参数不是 ptr1 的类型的基础或派生类型，则会出现编译器错误。

template <typename T> bool operator==(const QSharedPointer<T> &lhs, std::nullptr_t)

如果 lhs 引用了 nullptr，则返回 true。

另请参阅 QSharedPointer::isNull。

template <typename T> bool operator==(std::nullptr_t, const QSharedPointer<T> &rhs)

如果 rhs 引用了 nullptr，则返回 true。

另请参阅 QSharedPointer::isNull。

© 2024 The Qt Company Ltd. 本文档中包含的贡献文档的版权归各自所有者所有。本提供的文档按免费软件基金会发布的、在 http://www.gnu.org/licenses/fdl.html 上显示的《GNU自由文档许可证》第1.3版许可使用。Qt及其相应的标志是The Qt Company Ltd在芬兰及/或世界其他国家的商标。所有其他商标均为其各自所有者的财产。