<QtTypeTraits> - Qt Type Traits

Funktionsdokumentation

[constexpr noexcept(...)] template <typename T, typename U = T> T qExchange(T &obj, U &&newValue)

Ersetzt den Wert von „ obj “ durch „ newValue “ und gibt den alten Wert von „ obj “ zurück.

Dies ist die Qt-Implementierung von `std::exchange()`. Sie unterscheidet sich von `std::exchange()` lediglich dadurch, dass sie bereits vor C++20 ` constexpr ` und bereits vor C++23 `noexcept` ist.

Wir empfehlen dringend, std::exchange() zu verwenden, wenn Sie die Varianten aus C++20 oder C++23 nicht benötigen. Sie können qExchange() deaktivieren, indem Sie das Makro „ QT_NO_QEXCHANGE “ definieren.

So verwenden Sie `qExchange()`, um Move-Konstruktoren zu implementieren:

MyClass(MyClass &&other)
  : m_pointer{qExchange(other.m_pointer, nullptr)},
    m_int{qExchange(other.m_int, 0)},
    m_vector{std::move(other.m_vector)},
    ...

Für Mitglieder vom Typ „Klasse“ können wir `std::move()` verwenden, da deren Move-Konstruktor das Richtige tut. Bei skalaren Typen wie rohen Zeigern oder Ganzzahltypen entspricht ein Move jedoch einer Kopie, was insbesondere bei Zeigern nicht unseren Erwartungen entspricht. Daher können wir für solche Typen nicht std::move() verwenden, sondern müssen std::exchange()/qExchange() nutzen, um sicherzustellen, dass das Element des Quellobjekts bereits zurückgesetzt ist, wenn wir zur Initialisierung unseres nächsten Datenelements gelangen – was nützlich sein kann, falls der Konstruktor mit einer Ausnahme beendet wird.

So verwendet man `qExchange()`, um eine Schleife zu schreiben, die die durchlaufene Sammlung aufbraucht:

for (auto &e : qExchange(collection, {})
    doSomethingWith(e);

Dies entspricht dem folgenden, wesentlich ausführlicheren Code:

{
    auto tmp = std::move(collection);
    collection = {};                    // or collection.clear()
    for (auto &e : tmp)
        doSomethingWith(e);
}                                       // destroys 'tmp'

Dies ist vollkommen sicher, da die for-Schleife das Ergebnis von `qExchange()` so lange aufrechterhält, wie die Schleife läuft, wodurch die Deklaration einer temporären Variablen entfällt. Beachten Sie jedoch, dass `qExchange()` ein nicht-konstantes Objekt zurückgibt, sodass sich Qt-Container möglicherweise lösen können.

[constexpr noexcept, since 6.2] template <typename Enum> std::underlying_type_t<Enum> qToUnderlying(Enum e)

Konvertiert das Enumerator- e in den entsprechenden Wert, ausgedrückt im zugrunde liegenden Typ der Enumeration.

Diese Funktion wurde in Qt 6.2 eingeführt.