如何为成员创建一个shared_ptr？

Question

I'm not sure if I'm suffering more from a documentation error or a headache, so...

What I want to do is create a shared_ptr that shares ownership with another, but which references a member of the object instead of the whole object. Simple example, starting point...

struct s
{
  int a, b;
};

shared_ptr<s> s1 (new s);  //  pointing to whole object

From en.cppreference.com , constructor (8) of shared_ptr is...

template< class Y >
shared_ptr( const shared_ptr<Y>& r, T *ptr );

The description mentions "Constructs a shared_ptr which shares ownership information with r, but holds an unrelated and unmanaged pointer ptr ... such as in the typical use cases where ptr is a member of the object managed by r".

So... Was T just accidentally missed from the template in that constructor, or am I missing something? In fact, Y looks like it's wrong to me too, so just generally is that constructor described correctly?

What I'm hoping I can do is something like this...

shared_ptr<int> s2 (s1, &(s1.get ()->a));

s2 points to member a (an int ), but shares ownership of the whole object with s1 .

Is that sane?

Answer 1

The T parameter is a template parameter on the shared_ptr itself, whereas the Y parameter is a template parameter on that particular shared_ptr constructor. Something like this:

template< class T >
class shared_ptr
{
     template< class Y >
     shared_ptr( const shared_ptr<Y>& r, T *ptr );
}

As for the example code you've posted, that looks fine to me.

Answer 2

The documentation is correct. You're forgetting that this is the documentation of a constructor on the class template shared_ptr<T> ie the class-qualified declaration of the constructor is:

template<typename T>
template<typename Y>
shared_ptr<T>::shared_ptr(const shared_ptr<Y>& r, T *ptr);

So in your example T is int and Y is s .

Answer 3

T is the template parameter of the class, not of the constructor. And this is exactly as it needs to be: A pointer to a member has to have the type of the member and forget/erase (see type-erasure) the type of the containing object ( Y , in this case).

The code you posted should work, you can even write it a little simpler as:

shared_ptr<int> s2 (s1, &s1->a);