<QtTypeTraits> - Qt Type Traits

Documentation des fonctions

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

Remplace la valeur de ` obj ` par ` newValue ` et renvoie l'ancienne valeur de ` obj`.

Il s'agit de l'implémentation par Qt de std::exchange(). Elle ne diffère de std::exchange() que par le fait qu'elle est déjà constexpr avant C++20 et noexcept avant C++23.

Nous vous recommandons vivement d’utiliser std::exchange() lorsque vous n’avez pas besoin des variantes C++20 ou C++23. Vous pouvez désactiver qExchange() en définissant la macro QT_NO_QEXCHANGE.

Voici comment utiliser qExchange() pour implémenter des constructeurs de déplacement :

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

Pour les membres de type classe, nous pouvons utiliser std::move(), car leur constructeur de déplacement fonctionnera correctement. Mais pour les types scalaires tels que les pointeurs bruts ou les types entiers, le déplacement équivaut à une copie, ce qui, en particulier pour les pointeurs, n’est pas le résultat escompté. Nous ne pouvons donc pas utiliser std::move() pour ces types, mais nous pouvons utiliser std::exchange()/qExchange() pour nous assurer que le membre de l’objet source est déjà réinitialisé au moment où nous arrivons à l’initialisation de notre membre de données suivant, ce qui peut s’avérer utile si le constructeur se termine par une exception.

Voici comment utiliser qExchange() pour écrire une boucle qui épuise la collection sur laquelle elle itère :

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

Ce qui équivaut au code suivant, bien plus verbeux :

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

Cette approche est parfaitement sûre, car la boucle « for » maintient le résultat de qExchange() en vie tant que la boucle s’exécute, ce qui évite de devoir déclarer une variable temporaire. Notez toutefois que qExchange() renvoie un objet non-const, ce qui peut entraîner le détachement des conteneurs Qt.

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

Convertit l'e de l'énumérateur en la valeur équivalente exprimée dans le type sous-jacent de son énumération.

Cette fonction a été introduite dans Qt 6.2.