ความแตกต่างระหว่าง `const shared_ptr <T>` และ `shared_ptr <const T>`?

ฉันกำลังเขียนวิธีการเข้าถึงสำหรับตัวชี้ที่ใช้ร่วมกันใน C ++ ซึ่งมีลักษณะดังนี้:

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

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

ดังนั้นเพื่อรองรับ const-ness ของgetBar()ประเภทการส่งคืนควรเป็นสิ่งboost::shared_ptrที่ป้องกันการแก้ไขที่Barชี้ไป ฉันเดาว่าshared_ptr<const Bar>เป็นประเภทที่ฉันต้องการกลับไปทำเช่นนั้นในขณะที่const shared_ptr<Bar>จะป้องกันไม่ให้การกำหนดตัวชี้ซ้ำเพื่อชี้ไปยังตำแหน่งอื่นBarแต่อนุญาตให้แก้ไขสิ่งBarที่ชี้ไป ... อย่างไรก็ตามฉันไม่แน่ใจ ฉันจะขอบคุณมากถ้ามีคนที่รู้แน่ชัดสามารถยืนยันเรื่องนี้หรือแก้ไขฉันได้หากฉันเข้าใจผิด ขอบคุณ!

คุณพูดถูก shared_ptr<const T> p;คล้ายกับconst T * p;(หรือเท่ากันT const * p;) นั่นคือวัตถุปลายแหลมอยู่ในconstขณะที่const shared_ptr<T> p;มีความคล้ายคลึงกับT* const p;ซึ่งหมายความว่าเป็นp constสรุป:

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.

เดียวกันถือสำหรับและweak_ptrunique_ptr

boost::shared_ptr<Bar const>ป้องกันการแก้ไข Barวัตถุผ่านตัวชี้ที่ใช้ร่วมกัน ในฐานะที่เป็นค่าส่งคืนค่า const boost::shared_ptr<Bar> constหมายความว่าคุณไม่สามารถเรียกใช้ฟังก์ชันที่ไม่ใช่ const บนฟังก์ชันที่ส่งคืนชั่วคราว หากเป็นตัวชี้จริง (เช่นBar* const) มันจะถูกละเว้นโดยสิ้นเชิง

โดยทั่วไปถึงแม้ที่นี่กฎปกติใช้: constปรับเปลี่ยนสิ่งที่นำหน้ามันในboost::shared_ptr<Bar const>ที่Bar; ในboost::shared_ptr<Bar> constมันคืออินสแตนซ์ (นิพจน์boost::shared_ptr<Bar>ซึ่งเป็น 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;
}

ฉันต้องการการสาธิตอย่างง่ายตามคำตอบของ @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

}