c++ - Diferencia entre `const shared_ptr<T>` y `shared_ptr<const T>`?

boost shared-ptr

Question

Estoy escribiendo un método de acceso para un puntero compartido en C ++ que dice algo como esto:

class Foo {
public:
    return_type getBar() const {
        return m_bar;
    }

private:
    boost::shared_ptr<Bar> m_bar;
}

Entonces para soportar la getBar() de getBar() el tipo de retorno debería ser un boost::shared_ptr que previene la modificación de la Bar que apunta. Supongo que shared_ptr<const Bar> es el tipo que quiero volver a hacer, mientras que const shared_ptr<Bar> evitaría la reasignación del puntero para apuntar a una Bar diferente pero permitir la modificación de la Bar que apunta. .. Sin embargo, no estoy seguro. Le agradecería si alguien que sabe con certeza podría confirmar esto o corregirme si me equivoqué. ¡Gracias!

Answer 1

Tienes razón. shared_ptr<const T> p; es similar a const T * p; (o, de manera equivalente, T const * p; ), es decir, el objeto puntiagudo es const mientras que const shared_ptr<T> p; es similar a T* const p; lo que significa que p es const . En resumen:

shared_ptr<T> p;             ---> T * p;                                    : nothing is const
const shared_ptr<T> p;       ---> T * const p;                              : p is const
shared_ptr<const T> p;       ---> const T * p;       <=> T const * p;       : *p is const
const shared_ptr<const T> p; ---> const T * const p; <=> T const * const p; : p and *p are const.

Lo mismo vale para weak_ptr y unique_ptr .

Answer 2

boost::shared_ptr<Bar const> impide la modificación del objeto Bar través del puntero compartido. Como valor de retorno, const in boost::shared_ptr<Bar> const significa que no se puede llamar a una función no const en el temporal devuelto; si fuera por un puntero real (por ejemplo, Bar* const ), sería completamente ignorado.

En general, incluso aquí, se aplican las reglas habituales: const modifica lo que le precede: en boost::shared_ptr<Bar const> , la Bar ; en boost::shared_ptr<Bar> const , es la instanciación (la expresión boost::shared_ptr<Bar> que es const.

Answer 3

#Check this simple code to understand... copy-paste the below code to check on any c++11 compiler

#include <memory>
using namespace std;

class A {
    public:
        int a = 5;
};

shared_ptr<A> f1() {
    const shared_ptr<A> sA(new A);
    shared_ptr<A> sA2(new A);
    sA = sA2; // compile-error
    return sA;
}

shared_ptr<A> f2() {
    shared_ptr<const A> sA(new A);
    sA->a = 4; // compile-error
    return sA;
}

int main(int argc, char** argv) {
    f1();
    f2();
    return 0;
}