Sự khác biệt giữa `const shared_ptr <T>` và `shared_ptr <const T>`?

Tôi đang viết một phương thức truy cập cho một con trỏ dùng chung trong C ++ diễn ra như sau:

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

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

Vì vậy, để hỗ trợ const-ness của getBar()kiểu trả về phải là một boost::shared_ptrngăn cản việc sửa đổi Barnó trỏ tới. Tôi đoán đó shared_ptr<const Bar>là kiểu mà tôi muốn quay lại để làm điều đó, ngược lại const shared_ptr<Bar>sẽ ngăn việc gán lại chính con trỏ để trỏ đến một điểm khác Barnhưng cho phép sửa đổi điểm Barmà nó trỏ tới ... Tuy nhiên, tôi không chắc. Tôi sẽ đánh giá cao nếu ai đó biết chắc chắn có thể xác nhận điều này hoặc sửa cho tôi nếu tôi sai. Cảm ơn!

Bạn đúng rồi. shared_ptr<const T> p;tương tự với const T * p;(hoặc, tương đương, T const * p;), nghĩa là, đối tượng nhọn consttrong khi const shared_ptr<T> p;tương tự với T* const p;nghĩa plà const. Tóm tắt:

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.

Điều tương tự đối với weak_ptrvà unique_ptr.

boost::shared_ptr<Bar const> ngăn cản việc sửa đổi Bar đối tượng thông qua con trỏ được chia sẻ. Là một giá trị trả về, const in boost::shared_ptr<Bar> constcó nghĩa là bạn không thể gọi một hàm không phải const trên giá trị tạm thời được trả về; nếu nó dành cho một con trỏ thực (ví dụ Bar* const), nó sẽ hoàn toàn bị bỏ qua.

Nói chung, ngay cả ở đây, các quy tắc thông thường được áp dụng: constsửa đổi những gì đứng trước nó: in boost::shared_ptr<Bar const>, the Bar; trong boost::shared_ptr<Bar> const, đó là sự khởi tạo (biểu thức boost::shared_ptr<Bar>là const.

#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;
}

Tôi muốn phân chia đơn giản dựa trên câu trả lời của @Cassio Neri:

#include <memory>

int main(){
    std::shared_ptr<int> i = std::make_shared<int>(1);
    std::shared_ptr<int const> ci;

    // i = ci; // compile error
    ci = i;
    std::cout << *i << "\t" << *ci << std::endl; // both will be 1

    *i = 2;
    std::cout << *i << "\t" << *ci << std::endl; // both will be 2

    i = std::make_shared<int>(3);
    std::cout << *i << "\t" << *ci << std::endl; // only *i has changed

    // *ci = 20; // compile error
    ci = std::make_shared<int>(5);
    std::cout << *i << "\t" << *ci << std::endl; // only *ci has changed

}