puntatore Unico e const correttezza

Question

non mi aspettavo questo codice per compilare:

#include <iostream> 
#include <memory> 

class A 
{ 
public: 

    inline int get() const 
    { 
     return m_i; 
    } 

    inline void set(const int & i) 
    { 
     m_i = i; 
    } 

private: 

    int m_i; 
}; 

int main() 
{ 
    const auto ptr = std::make_unique<A>(); 

    ptr->set(666); // I do not like this line D:< 
    std::cout << ptr->get() << std::endl; 

    return 0; 
} 

Se PTR era un puntatore cruda C, sarei ok con quello. Ma dal momento che sto usando un puntatore intelligente , non riesco a capire quale sia la logica alla base di questo.

Uso il puntatore univoco per esprimere la proprietà , in Programmazione orientata agli oggetti questa può essere vista come una composizione di oggetto (relazione "parte di").

Ad esempio:

class Car 
{ 
    /** Engine built through some creational OO Pattern, 
     therefore it has to be a pointer-accessed heap allocated object **/ 
    std::unique_ptr<Engine> m_engine; 
}; 

Oppure:

class A 
{ 
    class Impl; 

    std::unique_ptr<A::Impl> m_impl; // PIMPL idiom 
}; 

Se un'istanza di una classe Car è costante, perché il motore non dovrebbe essere costante così? Se fosse un puntatore condiviso, mi sarei trovato perfettamente d'accordo.

C'è un puntatore intelligente che può riflettere il comportamento che voglio?

Answer 1

E 'piuttosto semplice:

const auto ptr = std::make_unique<A>(); 

Ciò significa che il puntatore stesso è costante! Ma l'oggetto che contiene non lo è. Puoi vedere che funziona al contrario ...

A *const ptr = new A(); 

È lo stesso. Il puntatore è costante (non può essere modificato per puntare altrove), ma l'oggetto non lo è.

Ora, probabilmente volevi dire che vuoi qualcosa di simile, no?

const auto ptr = std::make_unique<const A>(); 

Ciò creerà un puntatore costante a una costante A.

C'è anche questo altro modo ...

auto ptr = std::make_unique<const A>(); 

L'oggetto è costante, ma non il puntatore.

BTW: Quella "costante propagazione" di cui parli si applica anche al C++, nello stesso modo in cui l'hai dichiarata.