smart pointers advice

Question

Well I know there are good topics about smart pointers, but since I'm starting to use them extensively I want to know some recommendations on bad or dangerous uses, e.g:

• Raw-pointer conversions
• Smart pointers to references/References to smart pointers
• etc.

Thank you in advance.

(Added)

Suppose I've a class A with pointers to B as members, I can specify them as B* (raw-ptr) or as shared_ptr members.

class A
{
    B* ptr_b;
    shared_ptr<B> s_ptr_b;
}

If I don't understood bad,

ptr_b = new (B); // raw pointer of course
ptr_b = shared_ptr<B>(new B)   ; // safe, ownership to shared_ptr
s_ptr_b = new (B); // unsafe due to conversion from B* to shared_ptr<B>
s_ptr_b = shared_ptr<B>(new B)   ; // also safe, equal to case II?

[Added more...]

• Altough user Joe posted that the 3rd conversion was safe (X* to shared_ptr<X>), it's not safe and it is forbidden.

I'm left with some advices regarding:

• Passing shared_ptr<X> to functions expecting X*

• If X* x = shared_ptr<X>(new X) equals to shared_ptr<X> x = shared_ptr<X>(new X).

• Interaction between references and shared_ptr<>.

Thank you very much.

Answer 1

If you're using STL, never create containers of auto_ptr.

Technically, it shouldn't even compile but many platforms will not generate errors when compiling containers of auto_ptr.

Answer 2

http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Smart_Pointers

Answer 3

Don't use arrays with auto_ptr and shared_ptr, because these classes cannot delete arrays correctly.

Answer 4

It's dangerous to use smart pointers that allow implicit conversions together with lagacy APIs that use raw pointers. Yasper is one of them. It allows the following:

void f(yasper::ptr<foo> p) {
    // ...
}

int main() {
    foo * p = new foo;
    f(p); // thinking it accepts foo*
    p->doit(); // oops, it's deleted!
    delete p; // already done by yasper::ptr !
}

Good that boost::shared_ptr doesn't allow that :)

Answer 5

You have this muddled.

ptr_b = new (B); // raw pointer of course
ptr_b = shared_ptr<B>(new B)   ; // illegal, boost::shared_ptr should prevent this
s_ptr_b = new (B); // No automatic conversion in the boost::shared_ptr library
s_ptr_b = shared_ptr<B>(new B)   ; // explicit constructor and lack of operator=(T*) make this required.