C++ equivalente per dati membro java final

Question

In primo luogo, la mia ultima codifica è Java e non voglio "scrivere Java in C++".

Ecco l'accordo, devo creare una classe immutabile. È abbastanza semplice. L'unico problema è che ottenere i valori iniziali è un po 'di lavoro. Quindi non posso semplicemente chiamare le inizializzazioni per inizializzare i miei membri.

Quindi qual è il modo migliore per creare una classe del genere? E come posso esporre le mie proprietà immutabili/definitive al mondo esterno negli standard C++?

ecco una classe di esempio:

class Msg { 
    private: 
     int _rec_num; 
     int _seq; 
     string text; 
    public: 
     Msg(const char* buffer) { 
      // parse the buffer and get our member here... 
      // ... lots of code 
     } 

     // does this look like proper C++? 
     int get_rec_num() { return _rec_num; } 
    }; 

Answer 1

C++ offre alcuni buoni meccanismi per rendere la vostra classe immutabile. Che cosa si deve fare è:

• dichiarano tutti i metodi pubblici (e forse protette) const
• dichiarare (ma non definire) operator= come privati ​​

Questo farà sì che gli oggetti non possono essere modificati dopo che sono stati creati. Ora puoi fornire l'accesso ai tuoi membri dei dati ora immutabili in qualsiasi modo, utilizzando metodi const. Il vostro esempio guarda a destra, a condizione che si rendono const:

int get_rec_num() const { return _rec_num; } 

Answer 2

Su finalizzatori

Non c'è nessuno, si deve emulare. O utilizzando una funzione di pulizia o avendo tutte le risorse incapsulate nelle classi RAII. Il compilatore posizionerà dei macchinari statici nella tua applicazione per chiamare i distruttori sulle tue classi RAII --i.e., Quando escono dall'ambito, le risorse vengono rilasciate attraverso il distruttore.

Su immutabilità e inizializzazione

Generalmente se qualcosa è immutabile e const-correct la classe avrà tutti i suoi membri come const e l'unica volta che si arriva a "scrivere" per loro è quando la classe viene inizializzato. Tuttavia nel tuo caso potrebbe non essere possibile.

Suggerisco di raccogliere tutte le risorse e inizializzare la classe (tramite un costruttore non predefinito con membri const) una volta che li si dispone. L'altra alternativa (che non dimoro) è quella di avere una funzione mutatore che "afferma" di essere const corretta ma scrive sui valori const per un'inizializzazione di post-costruzione una tantum.

Answer 3

Sei sulla buona strada: usa getter per tutto, e senza alcun setter, la tua classe è effettivamente immutabile.

Tuttavia, non dimenticare alcuni dei casi d'angolo: è possibile dichiarare il metodo operator =() come privato e non implementarlo in modo che qualcuno non possa ignorare l'oggetto con l'operatore di assegnazione generato dal compilatore predefinito, ecc. .

Answer 4

// does this look like proper C++? 
    int get_rec_num() { return _rec_num; } 

Si dovrebbe usare

int get_rec_num() const { return _rec_num; } 

(vedi const che permette di chiamare il membro sugli oggetti const).

Answer 5

Contrassegnerei il membro immutabile come "const" e assegnargli un valore nell'elenco di inizializzazione del costruttore.

Vorrei anche analizzare il buffer fuori dalla classe e passare la stringa al costruttore.

Qualcosa di simile a questo:

class Msg { 
    private: 
    int _rec_num; 
    int _seq; 
    const std::string text; 
    public: 
    Msg(const std::string& str) : 
     text(str) 
    { 

    } 

    // does this look like proper C++? 
    int get_rec_num() const { return _rec_num; } 
}; 

// parse the buffer and get our parameter somewhere else 

NB:

Si dovrebbe fare in qualsiasi funzioni membro che non cambiano lo stato dei vostri interni di classe come 'const'; in quanto ciò ti consentirà di chiamarli con oggetti const.

È consigliabile evitare di utilizzare un file std :: string nei file di intestazione; come chiunque includa la tua intestazione ha questo 'uso' forzato su di loro.

Answer 6

Per rendere una variabile immutabile è necessario utilizzare la parola chiave const esempio const int _rec_num. Le variabili Const possono essere inizializzate solo tramite un initialisation list, che viene chiamato prima di qualsiasi codice nel costruttore. Ciò significa che non è possibile eseguire alcuna elaborazione nel costruttore che imposta le variabili membro const.

Hai due modi per aggirare questo, per prima cosa puoi creare un'altra classe interna che prende un buffer e lo analizza nelle tue variabili. Mettere una versione const di questo nella vostra classe di MSG e mettere questo nella lista di inizializzazione:

class MsgInner 
{ 
    public: 
    int _rec_num; 

    Msg(const char* buffer) { 
     // Your parsing code 
    } 
}; 

class Msg 
{ 
    public: 
    const MsgInner msg; 

    Msg(const char* buffer) : msg(buffer) 
    { // any other code } 
}; 

Questo forse non è così 'standard', ma è un altro punto di vista. Altrimenti puoi anche farlo come suggerito dalle altre risposte con i metodi get.

Answer 7

Prima di tutto, è possibile inizializzare i membri in modo efficiente e in fase di costruzione anche se sono stati dichiarati come const (che non è né necessario né consigliato).

Vorrei ancora suggerire che di dividere questa classe in due classi distinte (pseudo-codice):

// Msg: pure data object; copy constructible but not modifiable. 
class Msg 
{ 
public: 
    Msg(int rec_num, ...) 
    : rec_num_(rec_num) 
    ... 
    {} 

    int rec_num() const 
    { return rec_num_; } 
    ... 
private: 
    // prevent copying 
    Msg& operator=(Msg const&); 
private: 
    int rec_num_; 
}; 

// MsgParser: responsible for parsing the buffer and 
// manufacturing Msg's. 
class MsgParser 
{ 
public: 
    static Msg Parse(char const* buffer) 
    { 
    ... parse ... 
    return Msg(...); 
    } 
}; 

// Usage 
Msg const msg = MsgParser::Parse(buffer); 

Questo anche ben separa le preoccupazioni di detenzione e l'analisi dei dati in classi separate.