membri const Perché statici non possono apparire in un'espressione costante come 'interruttore'

Question

ho la seguente dichiarazione di alcuni membri static const

.h

class MyClass : public MyBase 
{ 
public: 
    static const unsigned char sInvalid; 
    static const unsigned char sOutside; 
    static const unsigned char sInside; 
    //(41 more ...) 
} 

cpp

const unsigned char MyClass::sInvalid = 0; 
const unsigned char MyClass::sOutside = 1; 
const unsigned char MyClass::sInside = 2; 
//and so on 

A un certo punto voglio usare quei valori in un interruttore come:

unsigned char value; 
... 
switch(value) { 
    case MyClass::sInvalid : /*Do some ;*/ break; 
    case MyClass::sOutside : /*Do some ;*/ break; 
    ... 
} 

Ma ho il seguente errore del compilatore: errore: "MyClass :: sInvalid" non può apparire in un'espressione costante.

Ho letto altro switch-non-può-essere-costante-roba e non ho trovato una risposta per me dal momento che non capisco perché quelli static const unsigned char non sono un'espressione costante.

Sto utilizzando gcc 4.5.

Answer 1

I problemi che vedete sono dovuti al fatto che questo

static const unsigned char sInvalid; 

non può essere un momento della compilazione espressione costante, dal momento che il compilatore non conosce il suo valore. Inizializzali nell'intestazione in questo modo:

class MyClass : public MyBase 
{ 
public: 
    static const unsigned char sInvalid = 0; 
    ... 

e funzionerà.

Answer 2

I valori sono in effetti const, ma non sono costanti in fase di compilazione.

Una condizione switch A è risolta in fase di compilazione, non in fase di esecuzione. È possibile inizializzare sInvalid per qualsiasi valore, purché sia ​​una sola volta e lo switch non lo saprebbe mai fino all'ora di esecuzione.

Sembra che tu stia meglio utilizzando enum s invece di static costanti. Oltre al fatto che avrebbe funzionato, sembra più appropriato dal punto di vista del design.

Answer 3

È possibile utilizzare il trucco enum per rendere costanti compilarli in tempo:

class MyClass 
{ 
public: 
    enum { 
     sInvalid, 
     sOutside, 
     sInside, 
     //(41 more ...) 
    }; 
}; 

Nel codice, è comunque possibile utilizzare l'enumerazione per assing a unsigned char, qualcosa di simile:

int main(int argc, char *argv[]) 
{ 
    unsigned char buf[32]; 
    buf[0] = MyClass::sInvalid; //int to unsigned char 
    return buf[0]; //Cast back to int (and avoid a warning a -Wall) 
} 

E utilizzare MyClass::sInvalid nelle dichiarazioni swith.