QSharedPointer Class
template <typename T> class QSharedPointerDie Klasse „QSharedPointer“ enthält eine starke Referenz auf einen Shared Pointer. Mehr...
| Header: | #include <QSharedPointer> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
Hinweis: Alle Funktionen dieser Klasse sind reentrant.
Vergleiche mit QSharedPointer
| Kategorie | Vergleichbare Typen | Beschreibung |
|---|---|---|
| strong | QSharedPointer | |
| strong | QSharedPointer<X>, X* und std::nullptr_t. | Dabei sind X und T kompatible Typen, d. h., sie sind entweder identisch oder der eine ist ein Basistyp des anderen. |
Ö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 & |
(since 6.9) QSharedPointer<X> | constCast() && |
| T * | data() const |
| QSharedPointer<X> | dynamicCast() const & |
(since 6.9) QSharedPointer<X> | dynamicCast() && |
| T * | get() const |
| bool | isNull() const |
| QSharedPointer<X> | objectCast() const & |
(since 6.9) QSharedPointer<X> | objectCast() && |
(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 & |
(since 6.9) QSharedPointer<X> | staticCast() && |
| void | swap(QSharedPointer<T> &other) |
| QWeakPointer<T> | toWeakRef() const |
| 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) |
Verwandte Nicht-Mitglieder
| 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) |
(since 6.9) QSharedPointer<X> | qSharedPointerCast(QSharedPointer<T> &&other) |
| QSharedPointer<X> | qSharedPointerConstCast(const QSharedPointer<T> &src) |
| QSharedPointer<X> | qSharedPointerConstCast(const QWeakPointer<T> &src) |
(since 6.9) QSharedPointer<X> | qSharedPointerConstCast(QSharedPointer<T> &&src) |
| QSharedPointer<X> | qSharedPointerDynamicCast(const QSharedPointer<T> &src) |
| QSharedPointer<X> | qSharedPointerDynamicCast(const QWeakPointer<T> &src) |
(since 6.9) QSharedPointer<X> | qSharedPointerDynamicCast(QSharedPointer<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) |
(since 6.9) QSharedPointer<X> | qSharedPointerObjectCast(QSharedPointer<T> &&src) |
(since 6.12) QSharedPointer<X> | qSharedPointerStaticCast(const QSharedPointer<T> &other) |
(since 6.12) QSharedPointer<X> | qSharedPointerStaticCast(const QWeakPointer<T> &other) |
(since 6.12) QSharedPointer<X> | qSharedPointerStaticCast(QSharedPointer<T> &&other) |
| 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> &lhs, const QSharedPointer<X> &rhs) |
| bool | operator!=(const QSharedPointer<T> &lhs, const X *rhs) |
| bool | operator!=(const QSharedPointer<T> &lhs, std::nullptr_t) |
| bool | operator!=(const T *lhs, const QSharedPointer<X> &rhs) |
| bool | operator!=(std::nullptr_t, const QSharedPointer<T> &rhs) |
| QDebug | operator<<(QDebug debug, const QSharedPointer<T> &ptr) |
| bool | operator==(const QSharedPointer<T> &lhs, const QSharedPointer<X> &rhs) |
| bool | operator==(const QSharedPointer<T> &lhs, const X *rhs) |
| bool | operator==(const QSharedPointer<T> &lhs, std::nullptr_t) |
| bool | operator==(const T *lhs, const QSharedPointer<X> &rhs) |
| bool | operator==(std::nullptr_t, const QSharedPointer<T> &rhs) |
Ausführliche Beschreibung
Der QSharedPointer ist ein automatischer, gemeinsam genutzter Zeiger in C++, bei dem der Template-Parameter „ T “ den Typ des verwalteten Zeigers angibt. Er verhält sich für normale Zwecke genau wie ein normaler Zeiger, einschließlich der Beachtung der „const“-Eigenschaft.
QSharedPointer löscht den von ihm gehaltenen Zeiger, sobald er den Gültigkeitsbereich verlässt, vorausgesetzt, kein anderes QSharedPointer-Objekt verweist darauf.
Ein QSharedPointer-Objekt kann aus einem normalen Zeiger, einem anderen QSharedPointer-Objekt oder durch die Umwandlung eines QWeakPointer -Objekts in eine starke Referenz erstellt werden.
Thread-Sicherheit
QSharedPointer und QWeakPointer sind reentrante Klassen. Das bedeutet, dass im Allgemeinen nicht mehrere Threads gleichzeitig ohne Synchronisation auf ein bestimmtes QSharedPointer- oder QWeakPointer -Objekt zugreifen können.
QWeakPointer Auf verschiedene QSharedPointer- und -Objekte kann von mehreren Threads gleichzeitig sicher zugegriffen werden. Dies gilt auch für den Fall, dass sie Zeiger auf dasselbe Objekt enthalten; der Referenzzählmechanismus ist atomar, und es ist keine manuelle Synchronisation erforderlich.
Es ist zu beachten, dass zwar auf den Zeigerwert auf diese Weise zugegriffen werden kann (d. h. von mehreren Threads gleichzeitig und ohne Synchronisation), QSharedPointer und QWeakPointer jedoch keine Garantie für das Objekt bieten, auf das verwiesen wird. Die spezifischen Regeln zur Thread-Sicherheit und Reentranz für dieses Objekt gelten weiterhin.
Andere Zeigerklassen
Qt stellt außerdem zwei weitere Zeiger-Wrapper-Klassen bereit: ` QPointer ` und ` QSharedDataPointer`. Diese sind untereinander nicht kompatibel, da jede von ihnen einen ganz anderen Anwendungsfall hat.
QSharedPointer verwaltet einen Shared Pointer mithilfe einer externen Referenzzählung (d. h. eines Referenzzählers, der außerhalb des Objekts platziert ist). 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 verweist, sollte jedoch nicht als gemeinsam genutzt betrachtet werden: Es gibt nur ein einziges Objekt. Aus diesem Grund bietet `QSharedPointer` keine Möglichkeit, das angezeigte Objekt zu trennen oder Kopien davon zu erstellen.
QSharedDataPointer QSharedData hingegen enthält einen Zeiger auf gemeinsam genutzte Daten (d. h. eine von abgeleitete Klasse). Dies geschieht mittels einer internen Referenzzählung, die in der Basisklasse „ “ hinterlegt ist. Diese Klasse kann daher je nach Art des Zugriffs auf die geschützten Daten die Verbindung trennen: Handelt es sich um einen Nicht-const-Zugriff, erstellt sie atomar eine Kopie, damit die Operation abgeschlossen werden kann. QSharedData
QExplicitlySharedDataPointer ist eine Variante von ` QSharedDataPointer`, mit dem Unterschied, dass sie sich nur löst, wenn ` QExplicitlySharedDataPointer::detach()` explizit aufgerufen wird (daher der Name).
QScopedPointer hält lediglich einen Zeiger auf ein im Heap zugewiesenes Objekt und löscht dieses in ihrem Destruktor. Diese Klasse ist nützlich, wenn ein Objekt im Heap zugewiesen und gelöscht werden muss, aber nicht mehr. ` QScopedPointer ` ist leichtgewichtig und verwendet keine zusätzlichen Strukturen oder Referenzzählungen.
Schließlich hält ` QPointer ` einen Zeiger auf ein von ` QObject` abgeleitetes Objekt, allerdings nur schwach. ` QWeakPointer ` verfügt über dieselbe Funktionalität, doch seine Verwendung für diesen Zweck ist veraltet.
Optionale Zeigerverfolgung
Eine Funktion von `QSharedPointer`, die zu Debugging-Zwecken zur Kompilierungszeit aktiviert werden kann, ist ein Zeigerverfolgungsmechanismus. Wenn diese Funktion aktiviert ist, registriert `QSharedPointer` alle von ihm verfolgten Zeiger in einem globalen Set. Dadurch lassen sich Fehler erkennen, wie beispielsweise die Zuweisung desselben Zeigers an zwei `QSharedPointer`-Objekte.
Diese Funktion wird aktiviert, indem das Makro „ QT_SHAREDPOINTER_TRACK_POINTERS “ vor dem Einbinden des QSharedPointer-Headers definiert wird.
Die Verwendung dieser Funktion ist auch bei Code, der ohne diese Funktion kompiliert wurde, unbedenklich. QSharedPointer stellt sicher, dass der Zeiger auch aus Code, der ohne Zeigerverfolgung kompiliert wurde, aus dem Tracker entfernt wird.
Beachten Sie jedoch, dass die Zeigerverfolgungsfunktion Einschränkungen bei Mehrfach- oder virtueller Vererbung unterliegt (d. h. in Fällen, in denen zwei verschiedene Zeigeradressen auf dasselbe Objekt verweisen können). In diesem Fall kann es vorkommen, dass der Zeigerverfolgungsmechanismus von QSharedPointer nicht erkennt, dass es sich bei dem verfolgten Objekt um dasselbe handelt, wenn ein Zeiger in einen anderen Typ umgewandelt wird und sich sein Wert ändert.
Siehe auch QSharedDataPointer, QWeakPointer, QScopedPointer und QEnableSharedFromThis.
Dokumentation der Mitgliedsfunktionen
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)
Erstellt eine „QSharedPointer“-Instanz und sorgt dafür, dass diese auf dasselbe Objekt verweist, auf das „ other “ verwiesen hat.
Einschränkungen
Nimmt nur dann an der Überladungsauflösung teil, wenn „ X* “ implizit in „ T* “ konvertiert wird.
[explicit] template <typename X> QSharedPointer::QSharedPointer(X *ptr)
Erstellt einen QSharedPointer, der auf ptr verweist. 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, sobald die letzte Referenz auf diesen QSharedPointer zerstört wird (auch wenn X nicht mit dem Template-Parameter T des QSharedPointer übereinstimmt). Zuvor wurde der Destruktor für T aufgerufen.
QSharedPointer::QSharedPointer(const QWeakPointer<T> &other)
Erzeugt einen QSharedPointer, indem die schwache Referenz „ other “ in eine starke Referenz umgewandelt und deren Zeiger gemeinsam genutzt wird.
Wenn ` T ` ein abgeleiteter Typ des Template-Parameters dieser Klasse ist, führt `QSharedPointer` eine automatische Typumwandlung durch. Andernfalls wird ein Compilerfehler ausgegeben.
Siehe auch ` QWeakPointer::toStrongRef()`.
QSharedPointer::QSharedPointer(std::nullptr_t)
Erzeugt einen QSharedPointer, der den Wert null hat. Dies entspricht dem Standardkonstruktor von QSharedPointer.
template <typename X, typename Deleter> QSharedPointer::QSharedPointer(X *ptr, Deleter d)
Erstellt einen `QSharedPointer`, der auf ` ptr` verweist. 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 Parameter „deleter“ d gibt den benutzerdefinierten Deleter für dieses Objekt an. Der benutzerdefinierte Deleter wird anstelle des Operators „delete()“ aufgerufen, wenn die starke Referenzanzahl auf 0 sinkt. Dies ist beispielsweise nützlich, um stattdessen „ deleteLater()“ auf ein „ 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 Template-Parameter ` T ` von `QSharedPointer` nicht identisch ist.
Es ist auch möglich, eine Memberfunktion 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 den Wert null hat. Dies entspricht dem Standardkonstruktor von QSharedPointer.
Der Deleter-Parameter d gibt den benutzerdefinierten Deleter für dieses Objekt an. Der benutzerdefinierte Deleter wird anstelle des Operators `delete()` aufgerufen, wenn die starke Referenzanzahl auf 0 sinkt.
QSharedPointer::QSharedPointer(const QSharedPointer<T> &other)
Erstellt ein QSharedPointer-Objekt, das den Zeiger von ` other` gemeinsam nutzt.
Wenn „ T “ ein abgeleiteter Typ des Template-Parameters dieser Klasse ist, führt QSharedPointer einen automatischen Typumwandlung durch. Andernfalls wird ein Compilerfehler ausgegeben.
[noexcept] QSharedPointer::QSharedPointer(QSharedPointer<T> &&other)
Erstellt eine QSharedPointer-Instanz und sorgt dafür, dass diese auf dasselbe Objekt verweist, auf das zuvor other verwiesen hat.
QSharedPointer::~QSharedPointer()
Löscht dieses „ QSharedPointer “-Objekt. Handelt es sich dabei um die letzte Referenz auf den gespeicherten Zeiger, wird dieser ebenfalls gelöscht.
void QSharedPointer::clear()
Löscht dieses „ QSharedPointer “-Objekt und hebt dabei den Verweis auf, den es möglicherweise auf den Zeiger hatte. Handelte es sich dabei um den letzten Verweis, wird der Zeiger selbst gelöscht.
template <typename X> QSharedPointer<X> QSharedPointer::constCast() const &
Führt einen „ const_cast “ vom Typ dieses Zeigers auf „ X “ durch und gibt einen „ QSharedPointer “ zurück, der die Referenz teilt. Diese Funktion kann sowohl für das Up- als auch für das Down-Casting verwendet werden, ist jedoch für das Up-Casting nützlicher.
Siehe auch ` isNull()` und ` qSharedPointerConstCast()`.
[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::constCast() &&
Das zurückgegebene ` QSharedPointer ` hat dieselben gemeinsamen Eigentümer wie ` *this`.
Diese Funktion ändert bei Erfolg die Adresse von ` resets ` von ` *this ` in ` nullptr `.
Diese Funktion überlädt ` QSharedPointer::constCast()`.
Diese Funktion wurde in Qt 6.9 eingeführt.
Siehe auch „ isNull()“ und „ qSharedPointerConstCast()“.
[static] template <typename... Args> QSharedPointer<T> QSharedPointer::create(Args &&... args)
Erstellt ein ` QSharedPointer `-Objekt und reserviert ein neues Element vom Typ ` T`. Die internen Komponenten von ` QSharedPointer ` und das Objekt werden in einem einzigen Speicherzuweisungsvorgang reserviert, was dazu beitragen kann, die Speicherfragmentierung in einer lang laufenden Anwendung zu verringern.
Diese Funktion versucht, einen Konstruktor für den Typ ` T ` aufzurufen, der alle übergebenen Argumente (args) akzeptieren kann. Die Argumente werden vollständig weitergeleitet.
T *QSharedPointer::data() const
Gibt den Wert des Zeigers zurück, auf den dieses Objekt verweist.
Hinweis: Löschen Sie den von dieser Funktion zurückgegebenen Zeiger nicht und übergeben Sie ihn nicht an eine andere Funktion, 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 eine dynamische Typumwandlung vom Typ dieses Zeigers auf ` X ` durch und gibt ein ` QSharedPointer ` zurück, das die Referenz teilt. Wird diese Funktion für einen Aufwärts-Cast verwendet, führt ` QSharedPointer ` einen ` dynamic_cast` durch. Das bedeutet: 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 dieselben Qualifizierer `const` und `volatile` aufweisen wie der Template dieses Objekts, andernfalls schlägt der Cast fehl. Verwenden Sie ` constCast()`, wenn Sie diese Qualifizierer entfernen müssen.
Siehe auch ` qSharedPointerDynamicCast()`.
[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::dynamicCast() &&
Das zurückgegebene ` QSharedPointer ` hat dieselben gemeinsamen Eigentümer wie ` *this`.
Diese Funktion leiten resets bei Erfolg *this an nullptr weiter.
Diese Funktion überlädt „ QSharedPointer::dynamicCast()“.
Diese Funktion wurde in Qt 6.9 eingeführt.
Siehe auch ` qSharedPointerDynamicCast()`.
T *QSharedPointer::get() const
Entspricht data().
Diese Funktion wird aus Gründen der API-Kompatibilität mit std::shared_ptr bereitgestellt.
bool QSharedPointer::isNull() const
Gibt „ true “ zurück, wenn dieses Objekt auf „ nullptr “ verweist.
template <typename X> QSharedPointer<X> QSharedPointer::objectCast() const &
Führt einen „ qobject_cast()“ vom Typ dieses Zeigers auf „ X “ durch und gibt ein „ QSharedPointer “ zurück, das die Referenz teilt. Wird diese Funktion für einen Upcast verwendet, führt „ QSharedPointer “ einen „ qobject_cast “ durch. Das bedeutet: 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 dieselben „const“- und „volatile“-Qualifizierer aufweisen wie die Vorlage dieses Objekts, andernfalls schlägt der Typumwandlung fehl. Verwenden Sie „ constCast()“, wenn Sie diese Qualifizierer entfernen müssen.
Siehe auch ` qSharedPointerObjectCast()`.
[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::objectCast() &&
Das zurückgegebene QSharedPointer teilt sich die Eigentumsrechte mit denselben gemeinsamen Eigentümern wie *this.
Diese Funktion ändert bei Erfolg die Adresse von resets von *this in nullptr.
Diese Funktion überlädt „ QSharedPointer::objectCast()“.
Diese Funktion wurde in Qt 6.9 eingeführt.
Siehe auch „ qSharedPointerObjectCast()“.
[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 “ zurück, genau dann, wenn dieser Smart-Pointer in einer implementierungsabhängigen, eigentümerbasierten Reihenfolge vor „ other “ steht. Die Reihenfolge ist so festgelegt, dass zwei Smart-Pointer als gleichwertig gelten, wenn sie beide leer sind oder wenn sie beide dasselbe Objekt besitzen (auch wenn ihr scheinbarer Typ und ihr Zeiger unterschiedlich sind).
Diese Funktionen wurden 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, genau dann, wenn dieser Smart-Pointer und „ other “ sich das Eigentumsrecht teilen.
Diese Funktionen wurden 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 eigentümerbasierten Hash-Wert für dieses Smart-Pointer-Objekt zurück. Smart-Pointer, die (gemäß owner_equal) als gleich angesehen werden, weisen einen identischen eigentümerbasierten Hash-Wert auf.
Diese Funktionen wurden in Qt 6.7 eingeführt.
Siehe auch owner_equal.
void QSharedPointer::reset()
Entspricht „ clear()“. Zur Kompatibilität mit std::shared_ptr.
void QSharedPointer::reset(T *t)
Setzt dieses „ QSharedPointer “-Objekt so zurück, dass es stattdessen auf „ t “ verweist. Entspricht:
QSharedPointer<T> other(t); this->swap(other);template <typename Deleter> void QSharedPointer::reset(T *t, Deleter deleter)
Setzt dieses „ QSharedPointer “-Objekt so zurück, dass es stattdessen auf „ t “ verweist, wobei der „Deleter“ „ deleter “ lautet. Entspricht:
QSharedPointer<T> other(t, deleter); this->swap(other);template <typename X> QSharedPointer<X> QSharedPointer::staticCast() const &
Führt eine statische Typumwandlung vom Typ dieses Zeigers auf ` X ` durch und gibt ein ` QSharedPointer ` zurück, das dieselbe Referenz verwendet. Diese Funktion kann sowohl für Up- als auch für Down-Casting verwendet werden, ist jedoch für Up-Casting nützlicher.
Hinweis: Der Vorlagentyp ` X ` muss dieselben Qualifizierer `const` und `volatile` aufweisen wie die Vorlage dieses Objekts, andernfalls schlägt die Typumwandlung fehl. Verwenden Sie ` constCast()`, wenn Sie diese Qualifizierer entfernen müssen.
Siehe auch ` dynamicCast()`, ` constCast()` und ` qSharedPointerStaticCast()`.
[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::staticCast() &&
Die zurückgegebene QSharedPointer teilt sich die Eigentumsrechte mit denselben gemeinsamen Eigentümern wie *this.
Diese Funktion leitet resets bei Erfolg von *this zu nullptr weiter.
Diese Funktion überlädt QSharedPointer::staticCast().
Diese Funktion wurde in Qt 6.9 eingeführt.
Siehe auch dynamicCast(), constCast() und qSharedPointerStaticCast().
[noexcept] void QSharedPointer::swap(QSharedPointer<T> &other)
Tauscht diese Instanz des Shared Pointers gegen „ other “ aus. Dieser Vorgang ist sehr schnell und schlägt niemals fehl.
QWeakPointer<T> QSharedPointer::toWeakRef() const
Gibt ein Objekt mit schwacher Referenz zurück, das denselben Zeiger verwendet, auf den dieses Objekt verweist.
Siehe auch ` QWeakPointer::QWeakPointer()`.
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 “, beispielsweise:
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 “, zum Beispiel:
if (!sharedptr) { /*...*/ }Siehe auch isNull().
T &QSharedPointer::operator*() const
Bietet Zugriff auf die Elemente des Shared Pointers.
Ist der enthaltene Zeiger ein „ nullptr “, ist das Verhalten undefiniert.
Siehe auch ` isNull()`.
T *QSharedPointer::operator->() const
Bietet Zugriff auf die Mitglieder des Shared Pointers.
Ist der enthaltene Zeiger ein „ nullptr “, ist das Verhalten undefiniert.
Siehe auch ` isNull()`.
[noexcept] QSharedPointer<T> &QSharedPointer::operator=(QSharedPointer<T> &&other)
other Weist der Instanz „ QSharedPointer “ die Instanz „ “ zu.
[noexcept] template <typename X> QSharedPointer<T> &QSharedPointer::operator=(QSharedPointer<X> &&other)
Weist „ other “ dieser Instanz von „ QSharedPointer “ zu.
Einschränkungen
Nimmt nur dann an der Überladungsauflösung teil, wenn X* implizit in T* konvertiert werden kann.
QSharedPointer<T> &QSharedPointer::operator=(const QSharedPointer<T> &other)
Lässt dieses Objekt den Zeiger von ` other` gemeinsam nutzen. Die aktuelle Zeigerreferenz wird verworfen, und falls es sich um die letzte handelte, wird der Zeiger gelöscht.
Wenn ` T ` ein abgeleiteter Typ des Template-Parameters dieser Klasse ist, führt ` QSharedPointer ` eine automatische Typumwandlung durch. Andernfalls wird ein Compilerfehler ausgegeben.
QSharedPointer<T> &QSharedPointer::operator=(const QWeakPointer<T> &other)
Erhöht „ other “ zu einer starken Referenz und sorgt dafür, dass dieses Objekt eine Referenz auf den von ihm referenzierten Zeiger teilt. Die aktuelle Zeigerreferenz wird verworfen, und falls es sich um die letzte handelte, wird der Zeiger gelöscht.
Wenn „ T “ ein abgeleiteter Typ des Template-Parameters dieser Klasse ist, führt „ QSharedPointer “ eine automatische Typumwandlung durch. Andernfalls wird ein Compilerfehler ausgegeben.
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 Shared-Pointer auf den von ` other` gehaltenen Zeiger zurück, der in den Typ ` X` umgewandelt wurde. Die Typen ` T ` und ` X ` müssen zu derselben Hierarchie gehören, damit ` static_cast ` erfolgreich ausgeführt werden kann.
Beachten Sie, dass X dieselben cv-Qualifizierer (const und volatile) aufweisen muss wie T, da der Code sonst nicht kompiliert werden kann. Verwenden Sie qSharedPointerConstCast, um die „const“-Eigenschaft aufzuheben.
Siehe auch QSharedPointer::staticCast(), qSharedPointerDynamicCast() und qSharedPointerConstCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerCast(const QWeakPointer<T> &other)
Gibt einen Shared-Pointer auf den von ` other` gehaltenen Zeiger zurück, der in den Typ ` X` umgewandelt wurde. Die Typen ` T ` und ` X ` müssen zu derselben Hierarchie gehören, damit ` static_cast ` erfolgreich ausgeführt werden kann.
Das Objekt ` other ` wird zunächst in eine starke Referenz umgewandelt. Wenn diese Umwandlung fehlschlägt (weil das Objekt, auf das es verweist, bereits gelöscht wurde), gibt diese Funktion einen ` QSharedPointer`-Wert von Null zurück.
Beachten Sie, dass „ X “ dieselben cv-Qualifizierer (const und volatile) aufweisen muss wie „ T “, da der Code sonst nicht kompiliert werden kann. Verwenden Sie „ qSharedPointerConstCast “, um die „const“-Eigenschaft aufzuheben.
Siehe auch QWeakPointer::toStrongRef(), qSharedPointerDynamicCast() und qSharedPointerConstCast().
[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerCast(QSharedPointer<T> &&other)
Die zurückgegebene QSharedPointer teilt sich die Eigentumsrechte mit denselben gemeinsamen Eigentümern wie other.
Diese Funktion wandelt bei Erfolg resets other in nullptr um.
Diese Funktion überlädt QSharedPointer::qSharedPointerCast(const QSharedPointer<T> &other).
Diese Funktion wurde in Qt 6.9 eingeführt.
Siehe auch QSharedPointer::staticCast(), qSharedPointerDynamicCast() und qSharedPointerConstCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &src)
Gibt einen Shared-Pointer auf den von ` src` gehaltenen Zeiger zurück, der in den Typ ` X` umgewandelt wurde. Die Typen ` T ` und ` X ` müssen zu derselben Hierarchie gehören, damit die ` const_cast ` erfolgreich ist. Die Unterschiede zwischen ` const ` und ` volatile ` bei ` T ` und ` X ` werden ignoriert.
Siehe auch QSharedPointer::constCast(), qSharedPointerStaticCast() und qSharedPointerDynamicCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerConstCast(const QWeakPointer<T> &src)
Gibt einen Shared-Pointer auf den von ` src` gehaltenen Zeiger zurück, der in den Typ ` X` umgewandelt wurde. Die Typen ` T ` und ` X ` müssen zu derselben Hierarchie gehören, damit die Funktion ` const_cast ` erfolgreich ausgeführt werden kann. Die Unterschiede zwischen ` const ` und ` volatile ` bei ` T ` und ` X ` werden ignoriert.
Das Objekt „ src “ wird zunächst in eine starke Referenz umgewandelt. Wenn diese Umwandlung fehlschlägt (weil das Objekt, auf das es verweist, bereits gelöscht wurde), gibt diese Funktion eine Null-Referenz „ QSharedPointer “ zurück.
Siehe auch QWeakPointer::toStrongRef(), qSharedPointerStaticCast() und qSharedPointerDynamicCast().
[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerConstCast(QSharedPointer<T> &&src)
Das zurückgegebene ` QSharedPointer ` hat dieselben gemeinsamen Eigentümer wie ` src`.
Diese Funktion wandelt bei Erfolg ` resets ` von ` src ` in ` nullptr ` um.
Diese Funktion überlädt QSharedPointer::qSharedPointerConstCast(const QSharedPointer<T> &src).
Diese Funktion wurde in Qt 6.9 eingeführt.
Siehe auch QSharedPointer::constCast(), qSharedPointerStaticCast() und qSharedPointerDynamicCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &src)
Gibt einen Shared-Pointer auf den von ` src` gehaltenen Zeiger zurück, wobei ein dynamischer Typumwandlung zum Typ ` X ` verwendet wird, um einen internen Zeiger des entsprechenden Typs zu erhalten. Falls der ` dynamic_cast ` fehlschlägt, ist das zurückgegebene Objekt `null`.
Beachten Sie, dass X dieselben cv-Qualifizierer (const und volatile) aufweisen muss wie T, da der Code sonst nicht kompiliert werden kann. Verwenden Sie qSharedPointerConstCast, um die „const“-Eigenschaft aufzuheben.
Siehe auch QSharedPointer::dynamicCast(), qSharedPointerStaticCast() und qSharedPointerConstCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerDynamicCast(const QWeakPointer<T> &src)
Gibt einen Shared-Pointer auf den von ` src` gehaltenen Zeiger zurück, wobei ein dynamischer Typumwandlung zum Typ ` X ` verwendet wird, um einen internen Zeiger des entsprechenden Typs zu erhalten. Wenn der ` dynamic_cast ` fehlschlägt, ist das zurückgegebene Objekt `null`.
Das Objekt ` src ` wird zunächst in eine starke Referenz umgewandelt. Scheitert diese Umwandlung (weil das Objekt, auf das es zeigt, bereits gelöscht wurde), gibt diese Funktion ebenfalls einen `null`-Wert vom Typ ` QSharedPointer` zurück.
Beachten Sie, dass „ X “ dieselben cv-Qualifizierer (const und volatile) aufweisen muss wie „ T “, da der Code sonst nicht kompiliert werden kann. Verwenden Sie „ qSharedPointerConstCast “, um die „const“-Eigenschaft aufzuheben.
Siehe auch QWeakPointer::toStrongRef(), qSharedPointerStaticCast() und qSharedPointerConstCast().
[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerDynamicCast(QSharedPointer<T> &&src)
Das zurückgegebene ` QSharedPointer ` hat dieselben gemeinsamen Eigentümer wie ` src`.
Diese Funktion wandelt bei Erfolg resets src in nullptr um.
Diese Funktion überlädt QSharedPointer::qSharedPointerDynamicCast(const QSharedPointer<T> &src).
Diese Funktion wurde in Qt 6.9 eingeführt.
Siehe auch QSharedPointer::dynamicCast(), qSharedPointerStaticCast() und qSharedPointerConstCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &src)
Die Funktion `qSharedPointerObjectCast` dient zum Umwandeln eines Shared Pointers.
Gibt einen Shared Pointer auf den von ` src` gehaltenen Zeiger zurück, wobei ein ` qobject_cast()` verwendet wird, um den Typ ` X ` zu ermitteln und einen internen Zeiger des entsprechenden Typs zu erhalten. Wenn die ` qobject_cast ` fehlschlägt, ist das zurückgegebene Objekt `null`.
Beachten Sie, dass X dieselben cv-Qualifizierer (const und volatile) aufweisen muss wie T, da der Code sonst nicht kompiliert werden kann. Verwenden Sie qSharedPointerConstCast, um die „const“-Eigenschaft aufzuheben.
Siehe auch QSharedPointer::objectCast(), qSharedPointerStaticCast() und qSharedPointerConstCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(const QWeakPointer<T> &src)
Die Funktion `qSharedPointerObjectCast` dient zum Umwandeln eines Shared Pointers.
Sie gibt einen Shared-Pointer auf den von ` src` gehaltenen Zeiger zurück, wobei ein ` qobject_cast()` auf ` X ` angewendet wird, um einen internen Zeiger des entsprechenden Typs zu erhalten. Wenn die ` 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 es zeigt, bereits gelöscht wurde), gibt diese Funktion ebenfalls einen null-Wert für „ QSharedPointer “ zurück.
Beachten Sie, dass „ X “ dieselben cv-Qualifizierer (const und volatile) aufweisen muss wie „ T “, andernfalls schlägt die Kompilierung fehl. Verwenden Sie „ qSharedPointerConstCast “, um die „const“-Eigenschaft aufzuheben.
Siehe auch QWeakPointer::toStrongRef(), qSharedPointerStaticCast() und qSharedPointerConstCast().
template <typename X, typename T> std::shared_ptr<X> qSharedPointerObjectCast(const std::shared_ptr<T> &src)
Gibt einen Shared-Pointer auf den von ` src` gehaltenen Zeiger zurück, wobei ein ` qobject_cast()` verwendet wird, um den Typ ` X ` zu ermitteln und einen internen Zeiger des entsprechenden Typs zu erhalten. Wenn die ` qobject_cast ` fehlschlägt, ist das zurückgegebene Objekt `null`.
Beachten Sie, dass X dieselben cv-Qualifizierer (const und volatile) aufweisen muss wie T, da der Code sonst nicht kompiliert werden kann. Verwenden Sie const_pointer_cast, um die const-Eigenschaft aufzuheben.
template <typename X, typename T> std::shared_ptr<X> qSharedPointerObjectCast(std::shared_ptr<T> &&src)
Gibt einen Shared-Pointer auf den von ` src` gehaltenen Zeiger zurück, wobei ` qobject_cast()` verwendet wird, um den Typ ` X ` zu ermitteln und einen internen Zeiger des entsprechenden Typs zu erhalten.
Wenn die Funktion „ qobject_cast “ erfolgreich ist, gibt die Funktion einen gültigen Shared-Pointer zurück, und „ src “ wird auf null zurückgesetzt. Wenn die Funktion „ qobject_cast “ fehlschlägt, ist das zurückgegebene Objekt null, und „ src “ wird nicht geändert.
Beachten Sie, dass „ X “ dieselben cv-Qualifizierer (const und volatile) aufweisen muss wie „ T “, da der Code sonst nicht kompiliert werden kann. Verwenden Sie „const_pointer_cast“, um die „const“-Eigenschaft aufzuheben.
[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(QSharedPointer<T> &&src)
Das zurückgegebene ` QSharedPointer ` hat dieselben gemeinsamen Eigentümer wie ` src`.
Diese Funktion wandelt bei Erfolg ` resets ` von ` src ` in ` nullptr ` um.
Diese Funktion überlädt „ QSharedPointer::qSharedPointerObjectCast(const QSharedPointer<T> &src)“.
Diese Funktion wurde in Qt 6.9 eingeführt.
Siehe auch QSharedPointer::objectCast(), qSharedPointerStaticCast() und qSharedPointerConstCast().
[since 6.12] template <typename X, typename T> QSharedPointer<X> qSharedPointerStaticCast(const QSharedPointer<T> &other)
Gibt einen Shared-Pointer auf den von ` other` gehaltenen Zeiger zurück, der in den Typ ` X` umgewandelt wurde. Die Typen ` T ` und ` X ` müssen zu derselben Hierarchie gehören, damit ` static_cast ` erfolgreich ausgeführt werden kann.
Beachten Sie, dass „ X “ dieselben cv-Qualifizierer (const und volatile) aufweisen muss wie „ T “, andernfalls schlägt die Kompilierung fehl. Verwenden Sie „ qSharedPointerConstCast “, um die „const“-Eigenschaft aufzuheben.
Diese Funktion wurde in Qt 6.12 eingeführt.
Siehe auch QSharedPointer::staticCast(), qSharedPointerDynamicCast() und qSharedPointerConstCast().
[since 6.12] template <typename X, typename T> QSharedPointer<X> qSharedPointerStaticCast(const QWeakPointer<T> &other)
Gibt einen Shared-Pointer auf den von ` other` gehaltenen Zeiger zurück, der in den Typ ` X` umgewandelt wurde. Die Typen ` T ` und ` X ` müssen zu derselben Hierarchie gehören, damit ` static_cast ` erfolgreich ausgeführt werden kann.
Das Objekt ` other ` wird zunächst in eine starke Referenz umgewandelt. Wenn diese Umwandlung fehlschlägt (weil das Objekt, auf das sie verweist, bereits gelöscht wurde), gibt diese Funktion ein `null`-` QSharedPointer` zurück.
Beachten Sie, dass „ X “ dieselben cv-Qualifizierer (const und volatile) aufweisen muss wie „ T “, da der Code sonst nicht kompiliert werden kann. Verwenden Sie „ qSharedPointerConstCast “, um die „const“-Eigenschaft aufzuheben.
Diese Funktion wurde in Qt 6.12 eingeführt.
Siehe auch QWeakPointer::toStrongRef(), qSharedPointerDynamicCast() und qSharedPointerConstCast().
[since 6.12] template <typename X, typename T> QSharedPointer<X> qSharedPointerStaticCast(QSharedPointer<T> &&other)
Das zurückgegebene ` QSharedPointer ` hat dieselben gemeinsamen Eigentümer wie ` other`.
Diese Funktion wandelt bei Erfolg resets other in nullptr um.
Diese Funktion überlädt QSharedPointer::qSharedPointerStaticCast(const QSharedPointer<T> &other).
Diese Funktion wurde in Qt 6.12 eingeführt.
Siehe auch QSharedPointer::staticCast(), qSharedPointerDynamicCast() und qSharedPointerConstCast().
template <typename X, typename T> std::shared_ptr<X> qobject_pointer_cast(const std::shared_ptr<T> &src)
Gibt einen Shared-Pointer auf den von ` src` gehaltenen Zeiger zurück.
Entspricht qSharedPointerObjectCast(). Diese Funktion wird aus Gründen der STL-Kompatibilität bereitgestellt.
template <typename X, typename T> std::shared_ptr<X> qobject_pointer_cast(std::shared_ptr<T> &&src)
Entspricht ` qSharedPointerObjectCast()`. Diese Funktion wird aus Gründen der STL-Kompatibilität bereitgestellt.
template <typename T, typename X> bool operator!=(const QSharedPointer<T> &lhs, const QSharedPointer<X> &rhs)
Gibt „ true “ zurück, wenn „ lhs “ und „ rhs “ auf unterschiedliche Zeiger verweisen.
Wenn sich der Template-Parameter von ` rhs` von dem von ` lhs` unterscheidet, muss ` QSharedPointer ` zunächst sicherstellen, dass es sich um kompatible Typen handelt. Dabei wird versucht, eine automatische Typumwandlung ( static_cast ) durchzuführen, um die Typen ` T ` und ` X ` in ihren zusammengesetzten Zeigertyp zu konvertieren. Wenn der Template-Parameter von ` rhs` kein Basis- oder abgeleiteter Typ von ` lhs` ist, wird ein Compilerfehler ausgegeben.
template <typename T, typename X> bool operator!=(const QSharedPointer<T> &lhs, const X *rhs)
Gibt „ true “ zurück, wenn „ lhs “ und „ rhs “ auf unterschiedliche Zeiger verweisen.
Wenn sich der Vorlagenparameter von ` rhs` von dem von ` lhs` unterscheidet, muss ` QSharedPointer ` zunächst sicherstellen, dass es sich um kompatible Typen handelt. Dabei wird versucht, eine automatische Typumwandlung ( static_cast ) durchzuführen, um die Typen ` T ` und ` X ` in ihren zusammengesetzten Zeigertyp umzuwandeln. Wenn der Vorlagenparameter von ` rhs` kein Basis- oder abgeleiteter Typ von ` lhs` ist, wird ein Compilerfehler ausgegeben.
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-null) Zeiger verweist.
Siehe auch QSharedPointer::isNull().
template <typename T, typename X> bool operator!=(const T *lhs, const QSharedPointer<X> &rhs)
Gibt „ true “ zurück, wenn der Zeiger „ lhs “ nicht mit dem Zeiger übereinstimmt, auf den „ rhs “ verweist.
Wenn sich der Template-Parameter von ` rhs` von dem von ` lhs` unterscheidet, muss ` QSharedPointer ` zunächst sicherstellen, dass es sich um kompatible Typen handelt. Dabei wird versucht, eine automatische Typumwandlung ( static_cast ) durchzuführen, um die Typen ` T ` und ` X ` in ihren zusammengesetzten Zeigertyp zu konvertieren. Wenn der Template-Parameter von ` rhs` kein Basis- oder abgeleiteter Typ von ` lhs` ist, wird ein Compilerfehler ausgegeben.
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-null) 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> &lhs, const QSharedPointer<X> &rhs)
Gibt „ true “ zurück, wenn „ lhs “ und „ rhs “ auf denselben Zeiger verweisen.
Wenn sich der Vorlagenparameter von ` rhs` von dem von ` lhs` unterscheidet, muss ` QSharedPointer ` zunächst sicherstellen, dass es sich um kompatible Typen handelt. Dabei wird versucht, eine automatische Typumwandlung ( static_cast ) durchzuführen, um die Typen ` T ` und ` X ` in ihren zusammengesetzten Zeigertyp zu konvertieren. Wenn der Vorlagenparameter von ` rhs` kein Basis- oder abgeleiteter Typ von ` lhs` ist, wird ein Compilerfehler ausgegeben.
template <typename T, typename X> bool operator==(const QSharedPointer<T> &lhs, const X *rhs)
Gibt „ true “ zurück, wenn „ lhs “ und „ rhs “ auf denselben Zeiger verweisen.
Wenn sich der Template-Parameter von „ rhs “ von dem von „ lhs “ unterscheidet, muss „ QSharedPointer “ zunächst sicherstellen, dass es sich um kompatible Typen handelt. Dabei wird versucht, eine automatische „ static_cast “ durchzuführen, um die Typen „ T “ und „ X “ in ihren zusammengesetzten Zeigertyp zu konvertieren. Wenn der Template-Parameter von „ rhs “ kein Basis- oder abgeleiteter Typ von „ lhs “ ist, wird ein Compilerfehler ausgegeben.
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 *lhs, const QSharedPointer<X> &rhs)
Gibt „ true “ zurück, wenn der Zeiger „ lhs “ derselbe ist wie der Zeiger, auf den „ rhs “ verweist.
Wenn sich der Template-Parameter von ` rhs` von dem von ` lhs` unterscheidet, muss ` QSharedPointer ` zunächst sicherstellen, dass es sich um kompatible Typen handelt. Dabei wird versucht, eine automatische Typumwandlung ( static_cast ) durchzuführen, um die Typen ` T ` und ` X ` in ihren zusammengesetzten Zeigertyp zu konvertieren. Wenn der Template-Parameter von ` rhs` kein Basis- oder abgeleiteter Typ von ` lhs` ist, wird ein Compilerfehler ausgegeben.
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().
© 2026 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.
