Propagare la costanza ai dati puntati dalle variabili membro

Question

Spesso è abbastanza confuso per i nuovi arrivati ​​C++ che le funzioni membro const sono autorizzati a chiamare metodi non-const sugli oggetti a cui fa riferimento la classe (tramite puntatore o riferimento). Ad esempio, il seguente è perfettamente corretto:

class SomeClass 
{ 
    class SomeClassImpl; 
    SomeClassImpl * impl_; // PImpl idiom 

    public:  

    void const_method() const; 
}; 

struct SomeClass::SomeClassImpl 
{ 
    void non_const_method() { /*modify data*/ } 
}; 

void SomeClass::const_method() const 
{ 
    impl_->non_const_method(); //ok because impl_ is const, not *impl_ 
}; 

Tuttavia, sarebbe a volte essere piuttosto utile se la costanza si propaga agli oggetti appuntiti (io ho usato volontariamente l'idioma Pimpl perché è uno dei casi in cui credo " la propagazione della costanza "sarebbe molto utile).

Quando si utilizza puntatori, questo può essere facilmente raggiunto utilizzando una sorta di puntatore intelligente con gli operatori di overload on constness:

template < typename T > 
class const_propagating_ptr 
{ 
    public: 

    const_propagating_ptr(T * ptr) : ptr_(ptr) {} 

    T  & operator*()  { return *ptr_; } 
    T const & operator*() const { return *ptr_; } 

    T  * operator->()  { return ptr_; } 
    T const * operator->() const { return ptr_; } 

    // assignment operator (?), get() method (?), reset() method (?) 
    // ... 

    private: 

    T * ptr_; 
}; 

Ora, ho solo bisogno di modificare SomeClass::impl_ essere un const_propagating_ptr<SomeClassImpl> per ottenere il comportamento desiderato .

Così ho alcune domande su questo:

1. ci sono alcuni problemi con costanza propagazione che ho trascurato?
2. In caso contrario, esistono librerie che forniscono classi per ottenere la propagazione della costanza?
3. Non sarebbe utile che i puntatori intelligenti comuni (unique_ptr, shared_ptr, ecc.) Forniscano un mezzo per ottenere questo comportamento (ad esempio attraverso un parametro template)?

Answer 1

1. Come osservato @Alf P. Steinbach, si ha supervisionato il fatto che la copia il puntatore dovesse produrre un non-const che punta allo stesso oggetto sottostante. Pimpl (sotto) eludono correttamente il problema eseguendo una copia profonda, unique_ptr lo circoscrive non essendo copiabili. È molto più facile, ovviamente, se l'oggetto è posseduto da una singola entità.

2. Boost.Optional si propaga costanza, tuttavia non è esattamente un puntatore (anche se modella il concetto OptionalPointee). Non conosco nessuna altra biblioteca.

3. Mi piacerebbe che lo forniscano di default. L'aggiunta di un altro parametro di modello (la classe dei tratti credo) non sembra valere la pena. Tuttavia ciò cambierebbe radicalmente la sintassi da un puntatore classico, quindi non sono sicuro che le persone sarebbero pronte ad abbracciarlo.

---

Codice della classe di Pimpl

template <class T> 
class Pimpl 
{ 
public: 
    /** 
    * Types 
    */ 
    typedef T value; 
    typedef const T const_value; 
    typedef T* pointer; 
    typedef const T* const_pointer; 
    typedef T& reference; 
    typedef const T& const_reference; 

    /** 
    * Gang of Four 
    */ 
    Pimpl() : _value(new T()) {} 
    explicit Pimpl(const_reference v) : _value(new T(v)) {} 

    Pimpl(const Pimpl& rhs) : _value(new T(*(rhs._value))) {} 

    Pimpl& operator=(const Pimpl& rhs) 
    { 
    Pimpl tmp(rhs); 
    swap(tmp); 
    return *this; 
    } // operator= 

    ~Pimpl() { boost::checked_delete(_value); } 

    void swap(Pimpl& rhs) 
    { 
    pointer temp(rhs._value); 
    rhs._value = _value; 
    _value = temp; 
    } // swap 

    /** 
    * Data access 
    */ 
    pointer get() { return _value; } 
    const_pointer get() const { return _value; } 

    reference operator*() { return *_value; } 
    const_reference operator*() const { return *_value; } 

    pointer operator->() { return _value; } 
    const_pointer operator->() const { return _value; } 

private: 
    pointer _value; 
}; // class Pimpl<T> 

// Swap 
template <class T> 
void swap(Pimpl<T>& lhs, Pimpl<T>& rhs) { lhs.swap(rhs); } 

// Not to be used with pointers or references 
template <class T> class Pimpl<T*> {}; 
template <class T> class Pimpl<T&> {}; 

Answer 2

Un approccio è quello di non utilizzare il puntatore direttamente se non attraverso due funzioni di accesso.

class SomeClass 
{ 
    private: 
    class SomeClassImpl; 
    SomeClassImpl * impl_; // PImpl idiom - don't use me directly! 

    SomeClassImpl * mutable_impl() { return impl_; } 
    const SomeClassImpl * impl() const { return impl_; } 

    public:  

    void const_method() const 
    { 
     //Can't use mutable_impl here. 
     impl()->const_method(); 
    } 
    void non_const_method() const 
    { 
     //Here I can use mutable_impl 
     mutable_impl()->non_const_method(); 
    } 
}; 

Answer 3

Per la cronaca, ho appena scoperto che il Loki library fornisce un puntatore const moltiplicazione (ConstPropPtr<T>). Sembra proprio come quello nella domanda, tranne che cancella anche il puntatore avvolto nel suo distruttore, ed è usato per implementare un Pimpl class simile a the one proposed by @Matthieu (ma non copiabile).

Answer 4

Se si pensa che dovrebbe "diffondere" const-ness, allora significa che non si ha realmente credete che sia un puntatore (o di riferimento), ma credo che sia un contenitore di : se il valore è costante quando l'oggetto è costante, è perché l'oggetto contiene il valore.

Quindi copiare l'oggetto copia il valore, almeno logicamente (CoW).

Se si insiste che sia un puntatore/riferimento IOW che è possibile copiare l'oggetto mentre si condivide il valore contenuto, allora si ha un'interfaccia (contraddittoria) non valida.

Conclusione: prendere una decisione. È un contenitore o un puntatore.

Un puntatore non si propaga const-ness, per definizione.