Come comprendere e progettare funzioni con argomenti di enumerazione che funzionano in tandem con operatori bit a bit in C ++ e Qt?

Nel C ++, ci sono 6 operatori bit a bit:

Symbol  Operator
&       bitwise AND
|       bitwise inclusive OR
^       bitwise XOR (eXclusive OR)
<<      left shift
>>      right shift
~        bitwise NOT (one's complement) (unary)

In Qt, ho visto | , ~ e & usati abbastanza spesso nelle funzioni:

file->open(QIODevice::WriteOnly | QIODevice::Truncate);

L'origine per tale funzione assomiglia a questa:

bool QFile::open(OpenMode mode)
{
    Q_D(QFile);
    if (isOpen()) {
        qWarning("QFile::open: File (%s) already open", qPrintable(fileName()));
        return false;
    }
    if (mode & Append)
        mode |= WriteOnly;

    unsetError();
    if ((mode & (ReadOnly | WriteOnly)) == 0) {
        qWarning("QIODevice::open: File access not specified");
        return false;
    }
    if (fileEngine()->open(mode)) {
        QIODevice::open(mode);
        if (mode & Append)
            seek(size());
        return true;
    }
    QFile::FileError err = fileEngine()->error();
    if(err == QFile::UnspecifiedError)
        err = QFile::OpenError;
    d->setError(err, fileEngine()->errorString());
    return false;
}

Il codice sorgente per l'enumerazione è simile a questo:

enum OpenModeFlag {
    NotOpen = 0x0000,
    ReadOnly = 0x0001,
    WriteOnly = 0x0002,
    ReadWrite = ReadOnly | WriteOnly,
    Append = 0x0004,
    Truncate = 0x0008,
    Text = 0x0010,
    Unbuffered = 0x0020,
    NewOnly = 0x0040,
    ExistingOnly = 0x0080
};
Q_DECLARE_FLAGS(OpenMode, OpenModeFlag)

Nel libro ho imparato Qt e C ++ from, non tocca in modo adeguato questi schemi di progettazione, quindi non sono nemmeno abbastanza sicuro di come leggere questo codice, o in che misura dovrei usare gli Operatori bitwise in tandem con le mie enumerazioni.

Domande

1. In che modo viene valutata la file->open(QIODevice::WriteOnly | QIODevice::Truncate)); in primo luogo? Valuta entrambe le enumerazioni in questo modo:

   QIODevice::WriteOnly > 0x0002 > 0000 0000 0000 0000 0000 0010
   QIODevice::Truncate  > 0x0008 > 0000 0000 0000 0000 0000 1000
                                 | 0000 0000 0000 0000 0000 1010
   

   ed esegui la funzione in questo modo?

   file->open(0000 0000 0000 0000 0000 1010); // 10 is not set in enum
   

2. Se questo è il caso, qual è la rilevanza del numero 10 in binario?

3. Perché i numeri impostati hanno tutti i poteri di 2?
4. Perché utilizzare gli esadecimali per i numeri e non per gli interi semplici?

5. Potrebbe essere applicato ogni operatore bit a bit alla funzione e come leggerlo? Questa sarebbe la mia ipotesi rudamentale:

   file->open(QIODevice::WriteOnly & QIODevice::Truncate); // Both have to be true?
   file->open(QIODevice::WriteOnly | QIODevice::Truncate); // At least one has to be true?
   file->open(QIODevice::WriteOnly ^ QIODevice::Truncate); // Only one has to be true?
   file->open(QIODevice::WriteOnly ~ QIODevice::Truncate); // WriteOnly has to be true and Truncate has to be false
   file->open(QIODevice::WriteOnly << QIODevice::Truncate);// ??? 
   file->open(QIODevice::WriteOnly >> QIODevice::Truncate);// ???
   

6. Nella sorgente della funzione, vedo anche cose come |= ; Che cosa fa?

7. Come leggere questa riga di codice: if ((mode & (ReadOnly | WriteOnly)) == 0) ?
8. In termini più pratici, quali sono le circostanze in cui userei ogni operatore bit a bit da utilizzare in tandem con le enumerazioni?

Grazie.