与类共享指针

Question

I'm amazed after seeing the example code. Because when I was saying myself, I got eventually what smart pointers are doing. But seems not yet. I really don't understand how the output shows 2014 . As far as I know, as far as it seems as well, the classes are apart. So there can't be relationship between them excepting inheritance, polymorphism, nested classing etc. I probably skip over some important points while studying smart pointers. Can someone illuminate the student?

#include <iostream>
#include <memory>

class classA
{
    std::shared_ptr<int> ptA;
public:
    classA(std::shared_ptr<int> p) : ptA(p) {}
    void setValue(int n) {
        *ptA = n;
    }
};

class classB
{
    std::shared_ptr<int> ptB;
public:
    classB(std::shared_ptr<int> p) : ptB(p) {}
    int getValue() const {
        return *ptB;
    }
};

int main()
{
    std::shared_ptr<int> pTemp(new int(2013));
    classA a(pTemp);
    classB b(pTemp);

    a.setValue(2014);
    std::cout << "b.getValue() = " << b.getValue() << std::endl;


}

Raw pointer output 2013 Code:

#include <iostream>
#include <memory>

class classA
{
    int* ptA;
public:
    classA(int * p) {
        ptA = new int(*p);
    }
    void setValue(int n) {
        *ptA = n;
    }
    ~classA() {
        delete ptA;
    }
};

class classB
{
    int* ptB;
public:
    classB(int *p) : ptB(p) {}
    int getValue() const {
        return *ptB;
    }
};

int main()
{
    int* pTemp(new int(2013));
    classA a(pTemp);
    classB b(pTemp);

    a.setValue(2014);
    std::cout << "b.getValue() = " << b.getValue() << std::endl;


}

Answer 1

What happens is that each std::shared_ptr object have it's own pointer (ie it has a member variable that is a pointer), but all of these pointers point to the same place.

Lets take an example using normal "raw" pointers:

int* p = new int(2013);

Now you have one pointer p pointing to some memory. If we do

int* p2 = p;

then we have two pointers, but both are pointing to the exact same memory .

This is similar to how shared_ptr works, each shared_ptr object have an internal pointer (a member variable), and each time the shared_ptr is copied (like when you pass it to a function) the internal member variable is initialized using the source-objects pointer variable (like the when p2 was initialized in the example above), leading to the member pointer variables of both objects pointing to the same memory.

Answer 2

Let's remove the smart pointer thing, because it seems to be just confusing you.

Your first code is like this, in summary:

int v = 2013;

int* p1 = &v;
int* p2 = &v;

*p1++;  // Makes v = 2014, so *p2 = 2014.

Your second version is like this:

int v1 = 2013;
int v2 = 2013;

int* p1 = &v1;
int* p2 = &v2;

*p1++;  // Makes v1 = 2014, but v2 = 2013