共享指针和const正确性

Question

Which is the correct way to extend the const correctness of a class to its pointed members? In the example code, is the constant version of the get method going to create an std::shared_ptr whose reference counter is the same as the internal member m_b , or is it starting again counting from 0 ?

class A
{
    std::shared_ptr< B > m_b;

public:

    std::shared_ptr< const B > get_b( ) const
    {
        return m_b;
    }

    std::shared_ptr< B > get_b( )
    {
        return m_b;
    }
}

Answer 1

shared_ptr will always preserve reference counts when you construct from another shared_ptr ; the only way to use it unsafely is to construct from a raw pointer: shared_ptr<...>(my_ptr.get()) // don't do this .

You may also be interested in the propagate_const wrapper, which is in the Library Fundamentals TS v2 so will probably be available in your implementation quite soon.

Answer 2

The answer can be deduced by doing some testing with use_count() .

Also notice how method resolution may be not completely obvious:

class B {};

class A {
  std::shared_ptr<B> m_b;

public:
  A() { m_b = std::make_shared<B>(); }

  std::shared_ptr<const B> get_b() const {
    std::cout << "const" << std::endl;
    return m_b;
  }

  std::shared_ptr<B> get_b() {
    std::cout << "non const" << std::endl;
    return m_b;
  }
};

int main(int, char **) {

  A a;

  std::shared_ptr<B> b = a.get_b();

  std::cout << b.use_count() << std::endl;

  std::shared_ptr<const B> cb = a.get_b();

  std::cout << cb.use_count() << std::endl;

  const A &a_const_ref = a;

  std::shared_ptr<const B> ccb = a_const_ref.get_b();

  std::cout << ccb.use_count() << std::endl;

  return 0;
}

Output:

non const
2
non const
3
const
4