Templated Stl Containers

Question

    template <class T>
    class container
    {
        typedef list<T> ObjectList;
public:
    ~container ()
    {
        for (typename ObjectList::iterator item = _Container.begin(); item != _Container.end(); item++)
        {
        if (*item) 
        delete (*item)
        }
    }
    }

how can i free the container items by deleting the pointer content? g++ not allow this code

Answer 1

Let's see:

1. _Container is never declared.

2. delete(*item) needs a semi-colon.

3. You don't need to test a pointer before deleteing it - you can delete 0.

4. You've got to be sure T is a pointer type.

5. Don't use raw pointers like this - it's better to use some good smart pointer.

Answer 2

You don't.

template<typename T>
class container {
    typedef list<T> list_t;
    list_t container_;
    // no user-defined destructor needed
};

The member "container_" manages its elements on its own.

If, however, you want to store pointers to dynamically allocated objects and let container take "ownership" (responsilibity to delete) you can iterate through the list and call delete on each element. But then, you also need to think about what should happen when this container object is copied or assigned to another one! The copies would share the same pointees and some elements might get deleted twice!

BTW: You should not use names that start with an underscore. Those names are reserved.

Answer 3

You don't want to do that -- the container (ObjectList, in your case) owns the items it contains, so to delete them, you need to tell it what you want, as in: ObjectList.erase(item);. Since you're (apparently) deleting all the items, you might as well use: ObjectList.clear(); and skip using your explicit loop at all.

Then again, since ObjectList is apparently an std::list, you don't need to do any of the above -- when you destroy an std::list, it automatically destroys whatever objects it contains.

Edit: (mostly in response to UncleBens' comment): If you're trying to create a container of pointers that manages deleting the items pointed to by the pointers it contains, then the first thing you want to do is ensure that it really contains pointers:

template <class T>
class container { 
    typedef typename std::list<T>::iterator it;
    std::list<T *> items;    // Note 'T *' rather than just "T"
public: 
    ~container() { 
        for (it p=items.begin; it!=items.end(); ++it)
             delete *it;     // *it yields a pointer from the container.      
    }    
};

Answer 4

• there are typo errors
• you are trying to delete which is not a pointer

Hope This will work for you !!!

template <class T>
class container
{

public:
    typedef list<T*> ObjectList;
    ~container ()
    {
        for (ObjectList::iterator item = _Container.begin(); item != _Container.end(); item++)
        {
      if (*item) 
       delete (*item);
        }
    }
    ObjectList _Container;
};

Answer 5

It is not immediately clear what you are trying to implement, but if you are trying to create a container that stores pointers to objects (instead of storing objects themselves), then a better technique would be to make a container of smart pointers (the specific kind of smart pointer depends on your intent). That would automatically take care of object lifetime management.

Answer 6

Stop trying to do this yourself and use a Boost Pointer Container.

Answer 7

Or you could use the boost ptr containers that do all the hard work for you.

http://www.boost.org/doc/libs/1%5F40%5F0/libs/ptr%5Fcontainer/doc/ptr%5Flist.html