Re: shared_ptr and unique_ptr related question

From:

James Kanze <james.kanze@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Sun, 23 Feb 2014 06:10:31 -0800 (PST)

Message-ID:

<5a3e4649-b67e-459f-8092-89486a4ebdac@googlegroups.com>

On Saturday, February 22, 2014 1:28:19 AM UTC, somenath wrote:

To get some understanding of shared_ptr and unique_ptr I wrote
the following naive implementation of linked list.

#include<memory>
using namespace std;

template <class T>
class List {
    private:
    class ListItem {
        public:
        ListItem( T Val );
        shared_ptr <ListItem > Next;
        T Data;
    };

    shared_ptr< ListItem >Head;

    public:
    int CreateNode();
    List() {
        Head.reset();
    }
    void PushBack(T Val);
    void Dump();
};

template<class T>
List<T>::ListItem::ListItem( T Val):Data(Val) {
    Next.reset();
}

template<class T>
void List<T>::PushBack( T val)
{
    unique_ptr<ListItem > NewItem (new ListItem(val));
    if (!Head ) {
    Head = move(NewItem);
    }
    else {
    shared_ptr<ListItem> Curr(Head);
    shared_ptr<ListItem> Prev(Head);
    while( (Curr) ) {
        Prev = Curr;
        Curr = Curr->Next;
    }
    Prev->Next = move(NewItem);
    }
}

template<class T>
void List<T>::Dump() {
    shared_ptr<ListItem > Curr(Head);
    while ( Curr) {
    cout<<"Val = "<<Curr->Data<<endl;;
    Curr = Curr->Next;
    }
}

But I am not very clear of the correct uses of shared_ptr and
auto_ptr yet.

Then don't use them. They're useful for some special cases; if
your use corresponds to one of those special cases, fine, but if
not, don't use them. Using them for memory contained in a
larger entity, like a list, is an anti-pattern.

Take a look at the implementations of the standard containers.
None of them use any classical smart pointers. (Most do use
private base classes to ensure correct destruction of partially
constructed objects. This is another technique, perhaps more
applicable to container classes in general.)

--
James