QFlags Class

label->setAlignment(Qt::AlignLeft | Qt::AlignTop);
label->setAlignment({ });

class MyClass_1
{
public:
    enum Option {
        NoOptions = 0x0,
        ShowTabs = 0x1,
        ShowAll = 0x2,
        SqueezeBlank = 0x4
    };
    Q_DECLARE_FLAGS(Options, Option)
    //...
};

Q_DECLARE_OPERATORS_FOR_FLAGS(MyClass_1::Options)

class MyClass_2
{
    Q_OBJECT
public:
    enum Option {
        NoOptions = 0x0,
        ShowTabs = 0x1,
        ShowAll = 0x2,
        SqueezeBlank = 0x4
    };
    Q_DECLARE_FLAGS(Options, Option)
    Q_FLAG(Options)
    //...
};

Q_DECLARE_OPERATORS_FOR_FLAGS(MyClass_2::Options)

Documentation sur les fonctions membres

[constexpr noexcept default] QFlags::QFlags()

Crée un objet QFlags sans aucun indicateur défini.

[constexpr noexcept] QFlags::QFlags(Enum flags)

Crée un objet QFlags contenant l'flags.

[constexpr noexcept] QFlags::QFlags(QFlag flag) requires (sizeof(Enum) == sizeof(int))

Crée un objet QFlags initialisé avec l'entier flag.

Le type ` QFlag ` est un type auxiliaire. En l'utilisant ici à la place de ` int`, nous garantissons ainsi que des valeurs d'énumération arbitraires ne peuvent pas être converties en `QFlags`, contrairement aux valeurs d'énumération non typées (c'est-à-dire les valeurs de type ` int `).

Ce constructeur n’existe que pour les types ` Enum ` 32 bits. Pour prendre en charge toutes les tailles d’énumération, envisagez d’utiliser le constructeur avec ` std::in_place_t`.

[constexpr noexcept] QFlags::QFlags(std::initializer_list<Enum> flags)

Crée un objet QFlags initialisé avec l'ensemble des flags combinées à l'aide de l'opérateur OR binaire.

Voir également ` operator|=()` et ` operator|()`.

[constexpr noexcept, since 6.9] QFlags::QFlags(std::in_place_t, QFlags<T>::Int flags)

Crée un objet QFlags initialisé avec l'flags, de type entier.

Cette fonction a été introduite dans Qt 6.9.

[implicit] QFlags::QFlags(const QFlags<T> &other)

Crée une copie de other.

[static constexpr noexcept, since 6.2] QFlags<T> QFlags::fromInt(QFlags<T>::Int i)

Crée un objet ` QFlags ` représentant la valeur entière ` i`.

Cette fonction a été introduite dans Qt 6.2.

[constexpr noexcept] QFlags<T> &QFlags::setFlag(Enum flag, bool on = true)

Active l'indicateur « flag » si « on » est « true » ou le désactive si « on » est « false ». Renvoie une référence à cet objet.

[constexpr noexcept, since 6.2] bool QFlags::testAnyFlag(Enum flag) const

Renvoie « true » si un indicateur défini dans « flag » est également défini dans cet objet « flags », sinon « false ». Si « flag » ne contient aucun indicateur défini, la valeur renvoyée sera toujours « false ».

Cette fonction a été introduite dans Qt 6.2.

Voir également testFlag().

[constexpr noexcept, since 6.2] bool QFlags::testAnyFlags(QFlags<T> flags) const

Renvoie « true » si un indicateur défini dans « flags » est également défini dans cet objet « flags », sinon « false ». Si « flags » ne contient aucun indicateur défini, la valeur renvoyée sera toujours « false ».

Cette fonction a été introduite dans Qt 6.2.

Voir également testFlags().

[constexpr noexcept] bool QFlags::testFlag(Enum flag) const

Renvoie « true » si l'indicateur « flag » est activé, sinon « false ».

Voir également ` testAnyFlag()`.

[constexpr noexcept, since 6.2] bool QFlags::testFlags(QFlags<T> flags) const

Renvoie ` true ` si cet objet `flags` correspond à l'objet ` flags` donné.

Si flags comporte des indicateurs activés, cet objet de drapeaux correspond exactement si tous les indicateurs activés dans flags le sont également dans cet objet de drapeaux. Dans le cas contraire, lorsque flags ne comporte aucun indicateur activé, cet objet de drapeaux ne correspond que s’il ne comporte lui-même aucun indicateur activé.

Cette fonction a été introduite dans Qt 6.2.

Voir également testAnyFlags().

[constexpr noexcept, since 6.2] QFlags<T>::Int QFlags::toInt() const

Renvoie la valeur stockée dans l'objet ` QFlags ` sous forme d'entier. Notez que l'entier renvoyé peut être signé ou non signé, selon que le type sous-jacent de l'énumération est signé ou non signé.

Cette fonction a été introduite dans Qt 6.2.

Voir aussi Int.

[constexpr noexcept] QFlags::operator QFlags<T>::Int() const

Renvoie la valeur stockée dans l'objet ` QFlags ` sous forme d'entier.

Voir aussi Int.

[constexpr noexcept] bool QFlags::operator!() const

Renvoie ` true ` si aucun indicateur n'est activé (c'est-à-dire si la valeur stockée par l'objet ` QFlags ` est égale à 0) ; sinon, renvoie ` false`.

[constexpr noexcept] QFlags<T> QFlags::operator&(int mask) const

Renvoie un objet ` QFlags ` contenant le résultat de l’opération de ET binaire entre cet objet et ` mask`.

Cet opérateur est désactivé si la macro ` QT_TYPESAFE_FLAGS ` est définie. Notez qu’il n’est pas étendu à 64 bits pour les objets ` QFlags ` 64 bits non plus : pour la prise en charge 64 bits, utilisez la surcharge sécurisée par type.

Voir également operator&=(), operator|(), operator^() et operator~().

[constexpr noexcept] QFlags<T> QFlags::operator&(Enum mask) const

[constexpr noexcept, since 6.2] QFlags<T> QFlags::operator&(QFlags<T> mask) const

Cette fonction a été introduite dans Qt 6.2.

[constexpr noexcept] QFlags<T> QFlags::operator&(uint mask) const

Cet opérateur est désactivé si la macro ` QT_TYPESAFE_FLAGS ` est définie. Notez qu’il n’est pas non plus étendu au 64 bits pour les ` QFlags ` 64 bits : pour la prise en charge du 64 bits, utilisez la surcharge « type-safe ».

[constexpr noexcept] QFlags<T> &QFlags::operator&=(int mask)

Effectue une opération de ET bit à bit avec ` mask ` et stocke le résultat dans cet objet ` QFlags `. Renvoie une référence à cet objet.

Cet opérateur est désactivé si la macro ` QT_TYPESAFE_FLAGS ` est définie. Notez qu’il n’est pas non plus étendu au 64 bits pour les objets ` QFlags ` 64 bits : pour la prise en charge du 64 bits, utilisez la surcharge sécurisée au niveau du type.

Voir également operator&(), operator|=() et operator^=().

[constexpr noexcept] QFlags<T> &QFlags::operator&=(Enum mask)

[constexpr noexcept, since 6.2] QFlags<T> &QFlags::operator&=(QFlags<T> mask)

Cette fonction a été introduite dans Qt 6.2.

[constexpr noexcept] QFlags<T> &QFlags::operator&=(uint mask)

Cet opérateur est désactivé si la macro ` QT_TYPESAFE_FLAGS ` est définie. Notez qu’il n’est pas non plus étendu au 64 bits pour les ` QFlags ` de 64 bits : pour la prise en charge du 64 bits, utilisez la surcharge « type-safe ».

[implicit] int &QFlags::operator=(const QFlags<T> &other)

Attribue la propriété « other » à cet objet et renvoie une référence à cet objet.

[constexpr noexcept] QFlags<T> QFlags::operator^(QFlags<T> other) const

Renvoie un objet ` QFlags ` contenant le résultat de l'opération XOR bit à bit entre cet objet et ` other`.

Voir également operator^=(), operator&(), operator|() et operator~().

[constexpr noexcept] QFlags<T> QFlags::operator^(Enum other) const

[constexpr noexcept] QFlags<T> &QFlags::operator^=(QFlags<T> other)

Effectue une opération XOR bit à bit avec other et stocke le résultat dans cet objet QFlags. Renvoie une référence à cet objet.

Voir également operator^(), operator&=() et operator|=().

[constexpr noexcept] QFlags<T> &QFlags::operator^=(Enum other)

[constexpr noexcept] QFlags<T> QFlags::operator|(QFlags<T> other) const

Renvoie un objet ` QFlags ` contenant le résultat de l'opération de OU binaire entre cet objet et ` other`.

Voir également operator|=(), operator^(), operator&() et operator~().

[constexpr noexcept] QFlags<T> QFlags::operator|(Enum other) const

[constexpr noexcept] QFlags<T> &QFlags::operator|=(QFlags<T> other)

Effectue une opération de OU binaire avec other et stocke le résultat dans cet objet QFlags. Renvoie une référence à cet objet.

Voir également operator|(), operator&=() et operator^=().

[constexpr noexcept] QFlags<T> &QFlags::operator|=(Enum other)

[constexpr noexcept] QFlags<T> QFlags::operator~() const

Renvoie un objet de type « QFlags » contenant la négation binaire de cet objet.

Voir également operator&(), operator|() et operator^().

typedef QFlags<Enum> Flags;