Back to Qt.io
Contact Us Blog Download Qt

QSharedPointer Class

template <typename T> class QSharedPointer

Die Klasse QSharedPointer enthält eine starke Referenz auf einen gemeinsamen Zeiger. Mehr...

Kopfzeile: #include <QSharedPointer>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core

Hinweis: Alle Funktionen in dieser Klasse sind reentrant.

Öffentliche Funktionen

QSharedPointer()
QSharedPointer(QSharedPointer<X> &&other)
QSharedPointer(X *ptr)
QSharedPointer(const QWeakPointer<T> &other)
QSharedPointer(std::nullptr_t)
QSharedPointer(X *ptr, Deleter d)
QSharedPointer(std::nullptr_t, Deleter d)
QSharedPointer(const QSharedPointer<T> &other)
QSharedPointer(QSharedPointer<T> &&other)
~QSharedPointer()
void clear()
QSharedPointer<X> constCast() const
T *data() const
QSharedPointer<X> dynamicCast() const
T *get() const
bool isNull() const
QSharedPointer<X> objectCast() const
(since 6.7) bool owner_before(const QSharedPointer<X> &other) const
(since 6.7) bool owner_before(const QWeakPointer<X> &other) const
(since 6.7) bool owner_equal(const QSharedPointer<X> &other) const
(since 6.7) bool owner_equal(const QWeakPointer<X> &other) const
(since 6.7) size_t owner_hash() const
void reset()
void reset(T *t)
void reset(T *t, Deleter deleter)
QSharedPointer<X> staticCast() const
void swap(QSharedPointer<T> &other)
QWeakPointer<T> toWeakRef() const
bool operator bool() const
bool operator!() const
T &operator*() const
T *operator->() const
QSharedPointer<T> &operator=(QSharedPointer<T> &&other)
QSharedPointer<T> &operator=(QSharedPointer<X> &&other)
QSharedPointer<T> &operator=(const QSharedPointer<T> &other)
QSharedPointer<T> &operator=(const QWeakPointer<T> &other)

Statische öffentliche Mitglieder

QSharedPointer<T> create(Args &&... args)
size_t qHash(const QSharedPointer<T> &key, size_t seed = 0)
QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &other)
QSharedPointer<X> qSharedPointerCast(const QWeakPointer<T> &other)
QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &src)
QSharedPointer<X> qSharedPointerConstCast(const QWeakPointer<T> &src)
QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &src)
QSharedPointer<X> qSharedPointerDynamicCast(const QWeakPointer<T> &src)
QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &src)
QSharedPointer<X> qSharedPointerObjectCast(const QWeakPointer<T> &src)
std::shared_ptr<X> qSharedPointerObjectCast(const std::shared_ptr<T> &src)
std::shared_ptr<X> qSharedPointerObjectCast(std::shared_ptr<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)
bool operator!=(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
bool operator!=(const QSharedPointer<T> &ptr1, const X *ptr2)
bool operator!=(const QSharedPointer<T> &lhs, std::nullptr_t)
bool operator!=(const T *ptr1, const QSharedPointer<X> &ptr2)
bool operator!=(std::nullptr_t, const QSharedPointer<T> &rhs)
QDebug operator<<(QDebug debug, const QSharedPointer<T> &ptr)
bool operator==(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
bool operator==(const QSharedPointer<T> &ptr1, const X *ptr2)
bool operator==(const QSharedPointer<T> &lhs, std::nullptr_t)
bool operator==(const T *ptr1, const QSharedPointer<X> &ptr2)
bool operator==(std::nullptr_t, const QSharedPointer<T> &rhs)

Detaillierte Beschreibung

Der QSharedPointer ist ein automatischer, gemeinsam genutzter Zeiger in C++. Er verhält sich für normale Zwecke genau wie ein normaler Zeiger, einschließlich der Beachtung von Konstanten.

QSharedPointer löscht den Zeiger, den er hält, wenn er den Gültigkeitsbereich verlässt, vorausgesetzt, dass keine anderen QSharedPointer-Objekte auf ihn verweisen.

Ein QSharedPointer-Objekt kann aus einem normalen Zeiger, einem anderen QSharedPointer-Objekt oder durch Promoting eines QWeakPointer -Objekts zu einer starken Referenz erzeugt werden.

Thread-Sicherheit

QSharedPointer und QWeakPointer sind reentrante Klassen. Das bedeutet, dass auf ein bestimmtes QSharedPointer- oder QWeakPointer -Objekt im Allgemeinen nicht von mehreren Threads gleichzeitig ohne Synchronisation zugegriffen werden kann.

Auf verschiedene QSharedPointer- und QWeakPointer -Objekte kann sicher von mehreren Threads gleichzeitig zugegriffen werden. Dies gilt auch für den Fall, dass sie Zeiger auf dasselbe Objekt enthalten; der Mechanismus der Referenzzählung ist atomar, und es ist keine manuelle Synchronisation erforderlich.

Es sollte beachtet werden, dass, während auf den Zeigerwert auf diese Weise zugegriffen werden kann (d.h. von mehreren Threads zur gleichen Zeit, ohne Synchronisation), QSharedPointer und QWeakPointer keine Garantie über das Objekt bieten, auf das gezeigt wird. Es gelten nach wie vor die spezifischen Regeln für die Threadsicherheit und Wiederholbarkeit für dieses Objekt.

Andere Zeiger-Klassen

Qt bietet auch zwei andere Zeiger-Wrapper-Klassen: QPointer und QSharedDataPointer. Sie sind nicht miteinander kompatibel, da sie jeweils einen ganz anderen Anwendungsfall haben.

QSharedPointer hält einen gemeinsamen Zeiger mittels eines externen Referenzzählers (d.h. eines Referenzzählers, der außerhalb des Objekts liegt). Wie der Name schon sagt, wird der Zeigerwert von allen Instanzen von QSharedPointer und QWeakPointer gemeinsam genutzt. Der Inhalt des Objekts, auf das der Zeiger zeigt, sollte jedoch nicht als gemeinsam genutzt betrachtet werden: Es gibt nur ein Objekt. Aus diesem Grund bietet QSharedPointer keine Möglichkeit, Kopien des Objekts, auf das der Zeiger zeigt, zu erstellen oder zu entfernen.

QSharedDataPointerQSharedPointer hingegen enthält einen Zeiger auf gemeinsam genutzte Daten (d. h. eine von QSharedData abgeleitete Klasse). Dies geschieht mittels einer internen Referenzzählung, die in der Basisklasse QSharedData platziert ist. Diese Klasse kann daher je nach Art des Zugriffs auf die zu schützenden Daten eine Trennung vornehmen: Wenn es sich um einen nicht-konstanten Zugriff handelt, wird eine Kopie atomar erstellt, damit die Operation abgeschlossen werden kann.

QExplicitlySharedDataPointer ist eine Variante von QSharedDataPointer, mit dem Unterschied, dass es sich nur ablöst, wenn QExplicitlySharedDataPointer::detach() explizit aufgerufen wird (daher der Name).

QScopedPointer hält einfach einen Zeiger auf ein im Heap allokiertes Objekt und löscht es in seinem Destruktor. Diese Klasse ist nützlich, wenn ein Objekt auf dem Heap alloziert und gelöscht werden muss, aber nicht mehr. QScopedPointer ist leichtgewichtig, sie macht keinen Gebrauch von zusätzlichen Strukturen oder Referenzzählungen.

QPointer schließlich hält einen Zeiger auf ein von QObject abgeleitetes Objekt, allerdings in schwacher Form. QWeakPointer hat die gleiche Funktionalität, aber seine Verwendung für diese Funktion ist veraltet.

Optionale Zeigerverfolgung

Eine Funktion von QSharedPointer, die zur Kompilierzeit zu Debugging-Zwecken aktiviert werden kann, ist ein Zeigerverfolgungsmechanismus. Wenn er aktiviert ist, registriert QSharedPointer alle Zeiger, die es verfolgt, in einer globalen Menge. Dies ermöglicht es, Fehler wie die Zuweisung desselben Zeigers an zwei QSharedPointer-Objekte zu erkennen.

Diese Funktion wird durch die Definition des QT_SHAREDPOINTER_TRACK_POINTERS Makros vor dem Einfügen des QSharedPointer Headers aktiviert.

Es ist sicher, diese Funktion auch mit Code zu verwenden, der ohne diese Funktion kompiliert wurde. QSharedPointer stellt sicher, dass der Zeiger aus dem Tracker entfernt wird, selbst bei Code, der ohne Zeigerverfolgung kompiliert wurde.

Beachten Sie jedoch, dass die Zeigerverfolgung Einschränkungen bei Mehrfachvererbung oder virtueller Vererbung hat (d.h. in Fällen, in denen zwei verschiedene Zeigeradressen auf dasselbe Objekt verweisen können). Wenn in diesem Fall ein Zeiger auf einen anderen Typ gecastet wird und sich sein Wert ändert, kann der Zeigerverfolgungsmechanismus von QSharedPointer möglicherweise nicht erkennen, dass das verfolgte Objekt dasselbe ist.

Siehe auch QSharedDataPointer, QWeakPointer, QScopedPointer, und QEnableSharedFromThis.

Dokumentation der Mitgliedsfunktionen

[noexcept, since 6.7] template <typename X> bool QSharedPointer::owner_before(const QSharedPointer<X> &other) const

[noexcept, since 6.7] template <typename X> bool QSharedPointer::owner_before(const QWeakPointer<X> &other) const

Gibt true nur dann zurück, wenn dieser Smart Pointer in einer implementierungsdefinierten, besitzerbasierten Reihenfolge vor other steht. Die Reihenfolge ist so, dass zwei intelligente Zeiger als äquivalent betrachtet werden, wenn sie beide leer sind oder wenn sie beide dasselbe Objekt besitzen (selbst wenn ihr offensichtlicher Typ und Zeiger unterschiedlich sind).

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch owner_equal.

[noexcept, since 6.7] template <typename X> bool QSharedPointer::owner_equal(const QSharedPointer<X> &other) const

[noexcept, since 6.7] template <typename X> bool QSharedPointer::owner_equal(const QWeakPointer<X> &other) const

Gibt true zurück, wenn und nur wenn dieser Smart Pointer und other denselben Eigentümer haben.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch owner_before und owner_hash.

[noexcept, since 6.7] size_t QSharedPointer::owner_hash() const

Gibt einen Owner-basierten Hash-Wert für dieses Smart-Pointer-Objekt zurück. Smart Pointer, die gleich verglichen werden (gemäß owner_equal), haben einen identischen Owner-basierten Hash-Wert.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch owner_equal.

QSharedPointer::QSharedPointer()

Erzeugt einen QSharedPointer, der null ist (das Objekt enthält einen Verweis auf nullptr).

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

Move-konstruiert eine QSharedPointer-Instanz, die auf das gleiche Objekt zeigt, auf das other gezeigt hat.

Dieser Konstruktor nimmt nur dann an der Überladungsauflösung teil, wenn X* implizit in T* konvertiert.

[explicit] template <typename X> QSharedPointer::QSharedPointer(X *ptr)

Erzeugt einen QSharedPointer, der auf ptr zeigt. Der Zeiger ptr wird von diesem QSharedPointer verwaltet und darf nicht an ein anderes QSharedPointer-Objekt übergeben oder außerhalb dieses Objekts gelöscht werden.

Seit Qt 5.8 wird ptr durch den Aufruf des Destruktors von X gelöscht, wenn die letzte Referenz auf diesen QSharedPointer zerstört wird (auch wenn X nicht mit dem Template-Parameter von QSharedPointer T identisch ist). Zuvor wurde der Destruktor für T aufgerufen.

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

Erzeugt einen QSharedPointer, indem er die schwache Referenz other in eine starke Referenz umwandelt und ihren Zeiger teilt.

Wenn T ein abgeleiteter Typ des Template-Parameters dieser Klasse ist, führt QSharedPointer einen automatischen Cast durch. Andernfalls erhalten Sie einen Compilerfehler.

Siehe auch QWeakPointer::toStrongRef().

QSharedPointer::QSharedPointer(std::nullptr_t)

Erzeugt einen QSharedPointer, der null ist. Dies entspricht dem Standardkonstruktor von QSharedPointer.

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

Erzeugt einen QSharedPointer, der auf ptr zeigt. Der Zeiger ptr wird von diesem QSharedPointer verwaltet und darf nicht an ein anderes QSharedPointer-Objekt übergeben oder außerhalb dieses Objekts gelöscht werden.

Der Deleter-Parameter d gibt den benutzerdefinierten Deleter für dieses Objekt an. Der benutzerdefinierte Deleter wird anstelle des Operators delete() aufgerufen, wenn die Anzahl der starken Referenzen auf 0 sinkt. Dies ist z.B. nützlich, um stattdessen deleteLater() auf einem QObject aufzurufen:

    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();
    }

Beachten Sie, dass die benutzerdefinierte Deleter-Funktion mit einem Zeiger auf den Typ X aufgerufen wird, auch wenn der QSharedPointer-Template-Parameter T nicht derselbe ist.

Es ist auch möglich, eine Mitgliedsfunktion direkt anzugeben, wie in:

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

Siehe auch clear().

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

Erzeugt einen QSharedPointer, der null ist. Dies entspricht dem QSharedPointer-Standardkonstruktor.

Der Deleter-Parameter d gibt den benutzerdefinierten Deleter für dieses Objekt an. Der benutzerdefinierte Deleter wird anstelle des Operators delete() aufgerufen, wenn die Anzahl der starken Referenzen auf 0 sinkt.

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

Erzeugt ein QSharedPointer-Objekt, das den Zeiger von other teilt.

Wenn T ein abgeleiteter Typ des Template-Parameters dieser Klasse ist, führt QSharedPointer einen automatischen Cast durch. Andernfalls erhalten Sie einen Compilerfehler.

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

Move-konstruiert eine QSharedPointer-Instanz, die auf das gleiche Objekt zeigt, auf das other gezeigt hat.

QSharedPointer::~QSharedPointer()

Zerstört dieses QSharedPointer Objekt. Wenn es sich um den letzten Verweis auf den gespeicherten Zeiger handelt, wird auch dieser Zeiger gelöscht.

void QSharedPointer::clear()

Löscht dieses QSharedPointer Objekt, wobei der Verweis, den es auf den Zeiger hatte, gelöscht wird. Wenn dies der letzte Verweis war, wird auch der Zeiger selbst gelöscht.

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

Führt ein const_cast vom Typ dieses Zeigers zu X durch und gibt ein QSharedPointer zurück, das die Referenz teilt. Diese Funktion kann sowohl für Up- als auch für Down-Casting verwendet werden, ist aber eher für Up-Casting geeignet.

Siehe auch isNull() und qSharedPointerConstCast().

[static] template <typename... Args> QSharedPointer<T> QSharedPointer::create(Args &&... args)

Dies ist eine überladene Funktion.

Erzeugt ein QSharedPointer Objekt und weist ein neues Element vom Typ T zu. Die Interna von QSharedPointer und das Objekt werden in einer einzigen Speicherzuweisung zugewiesen, was dazu beitragen kann, die Speicherfragmentierung in einer langlaufenden Anwendung zu verringern.

Diese Funktion versucht, einen Konstruktor für den Typ T aufzurufen, der alle übergebenen Argumente akzeptieren kann (args). Die Argumente werden perfekt weitergereicht.

T *QSharedPointer::data() const

Gibt den Wert des von diesem Objekt referenzierten Zeigers zurück.

Hinweis: Löschen Sie den von dieser Funktion zurückgegebenen Zeiger nicht und geben Sie ihn nicht an eine andere Funktion weiter, die ihn löschen könnte, einschließlich der Erstellung von QSharedPointer oder QWeakPointer Objekten.

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

Führt einen dynamischen Cast vom Typ dieses Zeigers nach X durch und gibt ein QSharedPointer zurück, das die Referenz teilt. Wenn diese Funktion für einen Up-Cast verwendet wird, führt QSharedPointer einen dynamic_cast durch, d.h. wenn das Objekt, auf das dieser QSharedPointer zeigt, nicht vom Typ X ist, ist das zurückgegebene Objekt null.

Hinweis: Der Template-Typ X muss die gleichen const- und volatile-Qualifier haben wie das Template dieses Objekts, sonst schlägt der Cast fehl. Verwenden Sie constCast(), wenn Sie diese Qualifizierer weglassen müssen.

Siehe auch qSharedPointerDynamicCast().

T *QSharedPointer::get() const

Dasselbe wie data().

Diese Funktion ist für die API-Kompatibilität mit std::shared_ptr vorgesehen.

bool QSharedPointer::isNull() const

Gibt true zurück, wenn dieses Objekt auf nullptr verweist.

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

Führt ein qobject_cast() vom Typ dieses Zeigers zu X durch und gibt ein QSharedPointer zurück, das die Referenz teilt. Wenn diese Funktion für ein Up-Casting verwendet wird, führt QSharedPointer ein qobject_cast durch, d.h. wenn das Objekt, auf das dieser QSharedPointer zeigt, nicht vom Typ X ist, ist das zurückgegebene Objekt null.

Hinweis: Der Template-Typ X muss die gleichen const- und volatile-Qualifier haben wie das Template dieses Objekts, sonst schlägt der Cast fehl. Verwenden Sie constCast(), wenn Sie diese Qualifizierer weglassen müssen.

Siehe auch qSharedPointerObjectCast().

void QSharedPointer::reset()

Dasselbe wie clear(). Für std::shared_ptr-Kompatibilität.

void QSharedPointer::reset(T *t)

Setzt dieses QSharedPointer Objekt zurück, so dass es stattdessen auf t zeigt. Äquivalent zu:

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

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

Setzt dieses QSharedPointer Objekt zurück, um stattdessen auf t zu zeigen, mit dem Deleter deleter. Äquivalent zu:

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

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

Führt einen statischen Cast vom Typ dieses Zeigers nach X durch und gibt eine QSharedPointer zurück, die die Referenz teilt. Diese Funktion kann sowohl für Up- als auch für Down-Casting verwendet werden, ist aber eher für Up-Casting nützlich.

Hinweis: Der Template-Typ X muss die gleichen const- und volatile-Qualifier haben wie das Template dieses Objekts, sonst schlägt der Cast fehl. Verwenden Sie constCast(), wenn Sie diese Qualifizierer weglassen müssen.

Siehe auch dynamicCast(), constCast(), und qSharedPointerCast().

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

Tauscht diese gemeinsame Zeigerinstanz mit other aus. Dieser Vorgang ist sehr schnell und schlägt nie fehl.

QWeakPointer<T> QSharedPointer::toWeakRef() const

Gibt ein schwaches Referenzobjekt zurück, das den von diesem Objekt referenzierten Zeiger teilt.

Siehe auch QWeakPointer::QWeakPointer().

bool QSharedPointer::operator bool() const

Gibt true zurück, wenn der enthaltene Zeiger nicht nullptr ist. Diese Funktion eignet sich für die Verwendung in if-constructs, wie:

    if (sharedptr) { ... }

Siehe auch isNull().

bool QSharedPointer::operator!() const

Gibt true zurück, wenn dieses Objekt auf nullptr verweist. Diese Funktion eignet sich für die Verwendung in if-constructs, wie:

    if (!sharedptr) { ... }

Siehe auch isNull().

T &QSharedPointer::operator*() const

Ermöglicht den Zugriff auf die Mitglieder des gemeinsamen Zeigers.

Wenn der enthaltene Zeiger nullptr ist, ist das Verhalten undefiniert.

Siehe auch isNull().

T *QSharedPointer::operator->() const

Ermöglicht den Zugriff auf die Mitglieder des gemeinsamen Zeigers.

Wenn der enthaltene Zeiger nullptr ist, ist das Verhalten undefiniert.

Siehe auch isNull().

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

Verschieben - weist other dieser QSharedPointer Instanz zu.

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

Move-weist other dieser QSharedPointer Instanz zu.

Dieser Zuweisungsoperator nimmt nur dann an der Überlastauflösung teil, wenn X* implizit in T* konvertiert.

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

Lässt dieses Objekt den Zeiger von other teilen. Die aktuelle Zeigerreferenz wird verworfen und, falls es die letzte war, wird der Zeiger gelöscht.

Wenn T ein abgeleiteter Typ des Template-Parameters dieser Klasse ist, wird QSharedPointer einen automatischen Cast durchführen. Andernfalls erhalten Sie einen Compilerfehler.

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

Erhöht other zu einer starken Referenz und lässt dieses Objekt eine Referenz auf den von ihm referenzierten Zeiger teilen. Die aktuelle Zeigerreferenz wird verworfen und, falls es die letzte war, wird der Zeiger gelöscht.

Wenn T ein abgeleiteter Typ des Template-Parameters dieser Klasse ist, wird QSharedPointer einen automatischen Cast durchführen. Andernfalls erhalten Sie einen Compilerfehler.

Verwandte Nicht-Mitglieder

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

Gibt den Hash-Wert für key zurück, wobei seed als Startwert für die Berechnung verwendet wird.

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

Gibt einen gemeinsamen Zeiger auf den Zeiger von other zurück, der in den Typ X umgewandelt wurde. Die Typen T und X müssen zu einer Hierarchie gehören, damit static_cast erfolgreich ist.

Beachten Sie, dass X die gleichen cv-qualifiers (const und volatile) haben muss wie T, sonst lässt sich der Code nicht kompilieren. Verwenden Sie qSharedPointerConstCast, um die Konstanten zu beseitigen.

Siehe auch QSharedPointer::staticCast(), qSharedPointerDynamicCast(), und qSharedPointerConstCast().

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

Gibt einen gemeinsamen Zeiger auf den Zeiger von other zurück, der in den Typ X umgewandelt wurde. Die Typen T und X müssen zu einer Hierarchie gehören, damit static_cast erfolgreich ist.

Das Objekt other wird zunächst in eine starke Referenz umgewandelt. Wenn diese Konvertierung fehlschlägt (weil das Objekt, auf das sie zeigt, bereits gelöscht wurde), gibt diese Funktion eine Null QSharedPointer zurück.

Beachten Sie, dass X die gleichen cv-qualifiers (const und volatile) haben muss wie T, sonst kann der Code nicht kompiliert werden. Verwenden Sie qSharedPointerConstCast, um die Konstante zu beseitigen.

Siehe auch QWeakPointer::toStrongRef(), qSharedPointerDynamicCast(), und qSharedPointerConstCast().

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

Gibt einen gemeinsamen Zeiger auf den Zeiger von src zurück, der in den Typ X umgewandelt wurde. Die Typen T und X müssen zu einer Hierarchie gehören, damit const_cast erfolgreich ist. Die Unterschiede zwischen const und volatile, T und X werden ignoriert.

Siehe auch QSharedPointer::constCast(), qSharedPointerCast(), und qSharedPointerDynamicCast().

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

Gibt einen gemeinsamen Zeiger auf den Zeiger von src zurück, der in den Typ X umgewandelt wurde. Die Typen T und X müssen zu einer Hierarchie gehören, damit const_cast erfolgreich ist. Die Unterschiede zwischen const und volatile, T und X werden ignoriert.

Das Objekt src wird zunächst in eine starke Referenz umgewandelt. Wenn diese Konvertierung fehlschlägt (weil das Objekt, auf das es verweist, bereits gelöscht wurde), gibt diese Funktion ein null QSharedPointer zurück.

Siehe auch QWeakPointer::toStrongRef(), qSharedPointerCast(), und qSharedPointerDynamicCast().

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

Gibt einen gemeinsamen Zeiger auf den von src gehaltenen Zeiger zurück, wobei ein dynamischer Cast auf den Typ X verwendet wird, um einen internen Zeiger des entsprechenden Typs zu erhalten. Wenn dynamic_cast fehlschlägt, ist das zurückgegebene Objekt null.

Beachten Sie, dass X die gleichen cv-qualifiers (const und volatile) haben muss wie T, sonst lässt sich der Code nicht kompilieren. Verwenden Sie qSharedPointerConstCast, um die Konstante zu beseitigen.

Siehe auch QSharedPointer::dynamicCast(), qSharedPointerCast(), und qSharedPointerConstCast().

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

Gibt einen gemeinsamen Zeiger auf den von src gehaltenen Zeiger zurück, wobei ein dynamischer Cast auf den Typ X verwendet wird, um einen internen Zeiger des entsprechenden Typs zu erhalten. Wenn dynamic_cast fehlschlägt, ist das zurückgegebene Objekt null.

Das Objekt src wird zunächst in eine starke Referenz umgewandelt. Wenn diese Konvertierung fehlschlägt (weil das Objekt, auf das sie zeigt, bereits gelöscht wurde), gibt diese Funktion ebenfalls null QSharedPointer zurück.

Beachten Sie, dass X die gleichen cv-qualifiers (const und volatile) haben muss wie T, sonst kann der Code nicht kompiliert werden. Verwenden Sie qSharedPointerConstCast, um die Konstante zu verwerfen.

Siehe auch QWeakPointer::toStrongRef(), qSharedPointerCast(), und qSharedPointerConstCast().

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

Die Funktion qSharedPointerObjectCast dient dem Casting eines gemeinsamen Zeigers.

Gibt einen gemeinsamen Zeiger auf den von src gehaltenen Zeiger zurück, wobei ein qobject_cast() auf den Typ X verwendet wird, um einen internen Zeiger des entsprechenden Typs zu erhalten. Wenn qobject_cast fehlschlägt, ist das zurückgegebene Objekt null.

Beachten Sie, dass X die gleichen cv-qualifiers (const und volatile) haben muss wie T, sonst lässt sich der Code nicht kompilieren. Verwenden Sie qSharedPointerConstCast, um die Konstante zu beseitigen.

Siehe auch QSharedPointer::objectCast(), qSharedPointerCast(), und qSharedPointerConstCast().

template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(const QWeakPointer<T> &src)

Die Funktion qSharedPointerObjectCast dient dem Casting eines gemeinsamen Zeigers.

Gibt einen gemeinsamen Zeiger auf den von src gehaltenen Zeiger zurück, wobei ein qobject_cast() auf den Typ X verwendet wird, um einen internen Zeiger des entsprechenden Typs zu erhalten. Wenn qobject_cast fehlschlägt, ist das zurückgegebene Objekt null.

Das Objekt src wird zunächst in eine starke Referenz umgewandelt. Wenn diese Umwandlung fehlschlägt (weil das Objekt, auf das sie zeigt, bereits gelöscht wurde), gibt diese Funktion ebenfalls null QSharedPointer zurück.

Beachten Sie, dass X die gleichen cv-qualifiers (const und volatile) haben muss wie T, sonst kann der Code nicht kompiliert werden. Verwenden Sie qSharedPointerConstCast, um die Konstante zu verwerfen.

Siehe auch QWeakPointer::toStrongRef(), qSharedPointerCast(), und qSharedPointerConstCast().

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

Gibt einen gemeinsamen Zeiger auf den von src gehaltenen Zeiger zurück, wobei ein qobject_cast() zum Typ X verwendet wird, um einen internen Zeiger des entsprechenden Typs zu erhalten. Wenn qobject_cast fehlschlägt, ist das zurückgegebene Objekt null.

Beachten Sie, dass X die gleichen cv-qualifiers (const und volatile) haben muss wie T, sonst lässt sich der Code nicht kompilieren. Verwenden Sie const_pointer_cast, um die Konstanten zu beseitigen.

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

Gibt einen gemeinsam genutzten Zeiger auf den Zeiger zurück, der von src gehalten wird, wobei ein qobject_cast() zum Typ X verwendet wird, um einen internen Zeiger des entsprechenden Typs zu erhalten.

Wenn qobject_cast erfolgreich ist, gibt die Funktion einen gültigen gemeinsamen Zeiger zurück, und src wird auf null zurückgesetzt. Wenn qobject_cast fehlschlägt, ist das zurückgegebene Objekt null, und src wird nicht geändert.

Beachten Sie, dass X die gleichen cv-qualifiers (const und volatile) haben muss wie T, sonst kann der Code nicht kompiliert werden. Verwenden Sie const_pointer_cast, um die Konstanten zu entfernen.

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

Gibt einen gemeinsamen Zeiger auf den von src gehaltenen Zeiger zurück.

Dasselbe wie qSharedPointerObjectCast(). Diese Funktion ist aus Gründen der STL-Kompatibilität vorgesehen.

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

Dasselbe wie qSharedPointerObjectCast(). Diese Funktion ist aus Gründen der STL-Kompatibilität vorgesehen.

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

Gibt true zurück, wenn ptr1 und ptr2 auf unterschiedliche Zeiger verweisen.

Wenn sich der Template-Parameter von ptr2 von dem von ptr1 unterscheidet, versucht QSharedPointer, eine automatische static_cast durchzuführen, um sicherzustellen, dass die verglichenen Zeiger gleich sind. Wenn der Template-Parameter von ptr2 kein Basistyp oder ein von ptr1 abgeleiteter Typ ist, erhalten Sie einen Compilerfehler.

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

Gibt true zurück, wenn ptr1 und ptr2 auf unterschiedliche Zeiger verweisen.

Wenn der Typ von ptr2 von dem von ptr1 abweicht, versucht QSharedPointer, eine automatische static_cast durchzuführen, um sicherzustellen, dass die verglichenen Zeiger gleich sind. Wenn der Typ von ptr2 kein Basistyp oder ein von diesem ptr1 abgeleiteter Typ ist, erhalten Sie einen Compilerfehler.

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

Gibt true zurück, wenn lhs auf einen gültigen (d. h. nicht leeren) Zeiger verweist.

Siehe auch QSharedPointer::isNull().

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

Gibt true zurück, wenn der Zeiger ptr1 nicht derselbe Zeiger ist wie der von ptr2 referenzierte.

Wenn der Template-Parameter von ptr2 nicht mit dem Typ von ptr1 übereinstimmt, versucht QSharedPointer, eine automatische static_cast durchzuführen, um sicherzustellen, dass die verglichenen Zeiger gleich sind. Wenn der Template-Parameter von ptr2 kein Basistyp oder ein von ptr1 abgeleiteter Typ ist, erhalten Sie einen Compilerfehler.

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

Gibt true zurück, wenn rhs auf einen gültigen (d. h. nicht leeren) Zeiger verweist.

Siehe auch QSharedPointer::isNull().

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

Schreibt den von ptr verfolgten Zeiger zu Debugging-Zwecken in das Debug-Objekt debug.

Siehe auch Debugging-Techniken.

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

Gibt true zurück, wenn ptr1 und ptr2 auf denselben Zeiger verweisen.

Wenn sich der Template-Parameter von ptr2 von dem von ptr1 unterscheidet, versucht QSharedPointer, einen automatischen static_cast durchzuführen, um sicherzustellen, dass die verglichenen Zeiger gleich sind. Wenn der Template-Parameter von ptr2 kein Basistyp oder ein von ptr1 abgeleiteter Typ ist, erhalten Sie einen Compilerfehler.

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

Gibt true zurück, wenn ptr1 und ptr2 auf denselben Zeiger verweisen.

Wenn der Typ von ptr2 von dem von ptr1 abweicht, versucht QSharedPointer, eine automatische static_cast durchzuführen, um sicherzustellen, dass die verglichenen Zeiger gleich sind. Wenn der Typ von ptr2 kein Basistyp oder ein von diesem ptr1 abgeleiteter Typ ist, erhalten Sie einen Compilerfehler.

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

Gibt true zurück, wenn lhs auf nullptr verweist.

Siehe auch QSharedPointer::isNull().

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

Gibt true zurück, wenn der Zeiger ptr1 derselbe Zeiger ist wie der von ptr2 referenzierte.

Wenn der Template-Parameter von ptr2 nicht mit dem Typ von ptr1 übereinstimmt, wird QSharedPointer versuchen, eine automatische static_cast durchzuführen, um sicherzustellen, dass die verglichenen Zeiger gleich sind. Wenn der Template-Parameter von ptr2 kein Basistyp oder ein von ptr1 abgeleiteter Typ ist, erhalten Sie einen Compilerfehler.

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

Gibt true zurück, wenn rhs auf nullptr verweist.

Siehe auch QSharedPointer::isNull().

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.