Breve problema:

Come dovrei controllare se gli interi sono indefiniti, così come posso controllare QStrings per avere valori NULL?

Backstory:

Questo è il mio stile di codifica quando cerco di evitare di sovraccaricare le mie funzioni.

MyClass.h

public:
    QString string();          // Return private member variables
    int integer();

    void setString(QString s); // Set private member variables
    void setInteger(int i);

signals:
    void stringChanged();      // Signal that member variable has been changed
    void integerChanged();

protected:
    void myFunction();         // Internal functions
    void resetMemberVariables();

private:
    QString m_String;          // Private member variables
    int m_Integer;

MyClass.cpp

QString MyClass::string()
{
    return m_Integer;
}
int MyClass::integer()
{
    return m_Integer;
}

void MyClass::setString(QString s)
{
    m_String = s;
    emit stringChanged();
}
void MyClass::setInteger(int i)
{
    m_Integer = i;
    emit integerChanged();
}

void MyClass::myFunction() 
{
    if (!m_String.isNull()) {}
    if (!m_Int.isNull()) { /* This is obviously impossible */ }
    resetMemberVariables();
}
void MyClass::resetMemberVariables()
{
    if (!m_String.isNull()) { 
        m_String = QString::null;
        emit stringChanged();
    }
    if (!m_Integer.isNull()) {   // Impossible
        m_Integer = NULL;        // Pretty sure this is wrong
        emit integerChanged();
    }
}

TLDR:

Invece di usare i parametri nelle funzioni, lascio che l'utente imposti le variabili membro e faccia eseguire il codice a seconda che la variabile membro sia stata definita o meno. Alla fine, ho reimpostato tutte le variabili membro su un valore NULL.

Da quanto ho capito, int non può avere un valore NULL perché ogni spazio di memoria può essere interpretato come un numero intero. (Per favore correggimi se è sbagliato.)

Quindi, come dovrei controllare se sono state impostate le mie variabili int ?

• Devo prenotare un numero fittizio?
• Dovrei accoppiarlo con un bool?
• Forse dovrei creare un QPair<int,bool> , il bool cambiando il suo stato definito o indefinito?