<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 de std::exchange() par Qt. Elle ne diffère de std::exchange() que par le fait qu'elle est constexpr avant C++20 et noexcept avant C++23.

Nous conseillons fortement d'utiliser std::exchange() lorsque vous n'avez pas besoin des variantes C++20 ou C++23. Vous pouvez rendre qExchange() indisponible en définissant la macro QT_NO_QEXCHANGE.

Voici comment utiliser qExchange() pour implémenter les constructeurs de mouvements :

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 d'un type de classe, nous pouvons utiliser std::move(), car leur constructeur de déplacement fera ce qu'il faut. Mais pour les types scalaires tels que les pointeurs bruts ou les entiers, move est la même chose que copy, ce qui, en particulier pour les pointeurs, n'est pas ce que nous attendons. 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 du membre de données suivant, ce qui peut s'avérer utile si le constructeur sort avec une exception.

Voici comment utiliser qExchange() pour écrire une boucle qui consomme la collection qu'elle parcourt :

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

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

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

C'est parfaitement sûr, car la boucle for garde le résultat de qExchange() en vie tant que la boucle tourne, ce qui permet d'économiser la déclaration d'une variable temporaire. Sachez cependant que qExchange() renvoie un objet non-const, de sorte que les conteneurs Qt peuvent se détacher.

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

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

Cette fonction a été introduite dans Qt 6.2.