Uso variabile di C++ Static Const membro

Question

Supponiamo di avere una classe che richiede alcune costanti per funzionare. Diverse funzioni membro richiedono l'uso di queste costanti. L'uso di #define è disapprovato poiché può causare collisioni. Le costanti sono modelli esadecimali di 8 o 16 bit e sono memorizzate come uint8_t o uint16_t. Queste costanti non cambiano anche da istanza ad istanza della classe, e quindi la memoria (anche se pochissima memoria) può essere salvata avendo una sola copia delle costanti.

C'è qualcosa di improprio, o forse di un modo migliore di realizzare quanto sopra, invece di limitarsi a fare qualcosa di simile al seguente:

// mycode.h 
// ....... 
class myclass { 
private: 
    static const uint16_t kMyClassConstant_ = 0xBEEF; 
// ....... 
}; 

Grazie in anticipo per l'aiuto.

Answer 1

Data la descrizione della situazione, direi che usare i membri static const è un buon approccio. In C++ 11 potresti volerlo cambiare in static constexpr per enfatizzare che è una costante in fase di compilazione, anche se nulla cambierà di conseguenza.

Se si fa riferimento a myclass::kMyClassContant_ da qualche parte nel codice in un modo che è rilevante ai sensi della regola a una definizione (odr), esp. in contesti che richiedono un riferimento (incluso il riferimento const), il compilatore si lamenterà che non esiste una definizione della costante. In questo caso non è sufficiente dichiararlo e inizializzarlo all'interno della classe. Questo può costringere a separare la dichiarazione e la definizione:

// mycode.h 
class myclass { 
private: 
    static const uint16_t kMyClassConstant_; 
}; 

// mycode.cpp 
const uint16_t myclass::kMyClassConstant_ = 0xBEEF; 

Per evitare la fatica di mantenere le dichiarazioni e le definizioni separati, alcune persone preferiscono dichiarare una funzione inline constexpr invece di una variabile reale:

// mycode.h 
class myclass { 
private: 
    static constexpr uint16_t kMyClassConstant_() 
    { return 0xBEEF; } 
}; 

Questo è un corretto work-around per molti dei problemi relativi a odr e non causa alcuna perdita di prestazioni. Se sia davvero utile dipende da quanto sia oneroso mantenere dichiarazioni e definizioni separate di una costante statica ordinaria. Se ti aspetti che le tue costanti non cambino mai mentre il tuo codice si evolve, è preferibile utilizzare costanti statiche ordinarie con definizioni separate. Ma se si modificano frequentemente le definizioni delle costanti, la necessità di ricompilare il file di definizione e ricollegarlo a tutte le parti rilevanti del progetto può far considerare la soluzione basata su funzioni come alternativa migliore.

Un commento finale sul tipo di dati: forzandolo a 16 bit utilizzando std::uint16_t può essere utile se è necessario memorizzare molti di questi valori in forma compatta. In caso contrario, le dimensioni effettive potrebbero non essere importanti, nel qual caso std::uint_fast16_t (che può essere maggiore di 16 bit) potrebbe essere migliore.

Answer 2

Si potrebbe utilizzare caratteri morfologici per implementare questo:

#include <type_traits> 

class myclass { 
private: 
    typedef std::integral_constant<uint16_t , 0xBEEF> kMyClassConstant; 

    // ... 
}; 

utilizzato come myclass::kMyClassConstant::value.

Questo mostra lo scopo dell'implementazione di una costante integrale e impedisce di prendere accidentalmente un indirizzo della costante.