È accettabile eliminare la costanza in un costruttore di mosse?

Question

Supponiamo che ho una classe Foo che ha un puntatore privato ad una Bar:

class Foo 
{ 
private: 
    Bar * bar; 

public: 
    Foo() : bar (new Bar()) 
    {} 

    ~Foo() 
    { 
    delete bar; 
    } 
}; 

Se il puntatore bar dovrebbe mai essere riassegnato a una diversa istanza, allora ha senso per rendere il puntatore stesso const al fine di fermare me (o un manutentore) dal farlo in futuro:

private: 
    Bar * const bar; 

mi piace fare questo ovunque l'occasione.

Se dunque io volevo scrivere un costruttore mossa, sarebbe simile a questa:

Foo (Foo && f) : 
    bar (f.bar) 
{ 
    f.bar = NULL; // uh oh; f.bar is const. 
} 

posso "fare l'errore di andare via" o gettando via la costanza di f.bar o non farcela const in primo luogo. Nessuno dei quali sono cose che voglio fare. Preferirei non rimuovere completamente il const perché è lì per un motivo. D'altra parte, gettare la costanza suona campanelli d'allarme per me ed è qualcosa che non faccio mai. La mia domanda è: è considerata una pratica accettabile per gettare via la costanza all'interno di un costruttore di mosse come questo? C'è un modo migliore che non ho considerato?

non credo che la mia domanda è la stessa come questo: Use const_cast to implement the move constructor

Answer 1

Se in alcuni casi è necessario modificare il puntatore (anche se si tratta di un solo caso), probabilmente non dovrebbe essere const.

Tuttavia, anche mettendo da parte questo pensiero, utilizzando const_cast per rimuovere la costanza da un oggetto e quindi utilizzando il risultato del cast viene richiamato un comportamento non definito. È sicuro di const_cast una variabile che originariamente non era const.

Answer 2

Tu sei fondamentalmente da soli contraddicendo.
Stai dicendo "Non voglio cambiarlo in nessuna circostanza", e stai dicendo "Voglio cambiarlo quando sposto un oggetto".

Quindi, se c'è uno scenario in cui deve essere modificato, non è un const e puoi stare tranquillo rimuovendolo.

Se si è determinato che lo si desidera const, è possibile aggiungere un altro valore booleano che determina la proprietà (se è necessario gestire la vita delle risorse). Quindi l'oggetto appuntito può essere rilasciato solo quando viene chiamato un distruttore che possiede l'oggetto.

Answer 3

Se possibile, utilizzare unique_ptr invece:

std::unique_ptr<Bar> bar; 
Foo(Foo&& f) : bar(std::move(f.bar)){} 
// or maybe you won't even have to declare move constructor 

In questo modo non solo si otterrà maggiore sicurezza e comfort, ma anche non si accidentalmente riscrivere con =, dovrete chiamare .reset() quindi ci penserai due volte prima di farlo (che è il tuo scopo, suppongo).