Using shared_ptr

When I'm using raw pointers it is pretty easy to 'travers' up/down the tree, but when I've employed shared_ptr instead of built-in pointers it isn't so. I m开发者_StackOverflow社区ean I just can't do (without side effects) just this:

shared_ptr<T> p(some_shared);

while (p->parent_)//here I'm assuming that the type pointed to has parent_ member
{
p = p->parent_;
}

This doesn't work for me because it looks like it resets p->parent when it assigns to p and that's not what I want.

Any clues?

Edit

This is real code:

template<class Key_T, class Value_T>
class Node
{

public:
    /*typedefs*/
    #define ptr_type std::shared_ptr

    typedef Key_T key_type;
    typedef ptr_type<key_type> key_ptr;
    typedef Value_T value_type;
    typedef ptr_type<value_type> value_ptr;

    typedef Colors color_type;
    typedef color_type* color_raw_ptr;
    typedef ptr_type<color_type> color_ptr;

    typedef std::pair<key_ptr,value_ptr> data_type;
    typedef ptr_type<data_type> data_ptr;

    typedef Node<key_type,value_type> node_type;
    typedef node_type* node_raw_ptr;
    typedef ptr_type<node_type> node_ptr; 
    explicit Node()
    {}
    explicit Node(const key_type& key,
        const value_type& value, 
        const color_type& color,
        node_ptr parent = nullptr,
        node_ptr left = nullptr,
        node_ptr right = nullptr);

        ~Node()
    {
        cout << "Bye now";
    }

    const node_ptr& root()const
    {
        node_ptr tmp = node_ptr(this);
        while (tmp->parent_)
        {///this seems to reset resources

            tmp = tmp->parent_;

        }

        return tmp;
    }
private:

    data_ptr data_;
    color_ptr color_;

    node_ptr parent_;
    node_ptr left_;
    node_ptr right_;


};

You cannot create a shared pointer from this as you do in

node_ptr tmp = node_ptr(this);

When you create a shared pointer, it assumes ownership of the pointer given to it - so this deletes this when tmp is reassigned.

On the subject of shared_ptr to this: http://www.boost.org/doc/libs/1_47_0/libs/smart_ptr/sp_techniques.html#from_this

You need to create shared pointers always like this:

node_ptr tmp = node_ptr(new node());

So how do you get a shared pointer to root()? If you would use boost, you would have shared_from_this: http://www.boost.org/doc/libs/1_47_0/libs/smart_ptr/enable_shared_from_this.html

You can use normal pointers, or make the function external or static to the class, taking shared_ptr as an argument.

Is there any reason that you should be manipulating smart pointers? Since you're writing synchronous code and the structure doesn't seem lazy you're not really concerned with issues of ownership -- this is a dumb traversal. So it's okay to use raw pointers.