Vinzenz Feenstra’s WebLog

#include <cstdlib>
#include <string>
#include <iostream>
#include <vector>
#include <list>
#include <set>
namespace container_utils
{
    namespace helper
    {
        template < typename T >
        struct isPointer
        {
            enum { Result = 0 };
            typedef T Type;
            typedef T* Pointer;
        };
 
        template< typename T>
        struct isPointer<T*>
        {
            enum { Result = 1 };
            typedef T Type;
            typedef T* Pointer;
        };
 
        template< class Container ,
        class Type = typename Container::value_type,
            bool Ptr = isPointer<Type>::Result
        >
        struct container_cleanup
        {
            container_cleanup(Container & cont)
            {
                cont.clear(); // erasing all elements
            }
        };
 
        template< class Container ,
        class Type
        >
        struct container_cleanup<Container,Type,true>
        {
            container_cleanup( Container & cont)
            {
                typename Container::iterator it;
                for (it = cont.begin(); it != cont.end(); ++it)
                    delete *it;
                cont.clear(); // erasing all elements
            }
        };
    } // namespace container_utils::helper
 
    /** This is the function will be called by us
    * It will be decided at compile time which clear type will be used
    */
    template < class Container >
        void clean( Container & cont )
    {
        helper::container_cleanup<Container> tmp(cont);
    }
} //namespace container_utils
 
 
struct A
{
    A()
    {
        std::cout << “A Constructed” << std::endl;
    }
    ~A()
    {
        std::cout << “A Destructed “ << std::endl;
    }
};
struct B
{
    static int num;
    int value;
    B()
    {
        std::cout << “B Constructed” << std::endl;
        value = ++num;
    }
    ~B()
    {
        std::cout << “B Destructed “ << std::endl;
    }
    bool operator< ( B const & rhs ) const
    {
        return this->value < rhs.value;
    }
};
int B::num = 0;
 
int main()
{
    // Test mit std::list<>
    std::list<B> a_list;
 
    for(unsigned i = 0; i < 10 ; ++i)
        a_list.push_back(B());
 
    container_utils::clean(a_list);
 
    std::cout << “############################################” << std::endl;
    // Test mit std::set<>
    std::set<B> a_set;
    for(unsigned i = 0; i < 10 ; ++i)
        a_set.insert(B());
 
    container_utils::clean(a_set);
 
    std::cout << “############################################” << std::endl;
    // Test mit std::vector<>
    std::vector<A*> vec_ptr;
    for(unsigned i = 0; i < 10 ; ++i)
        vec_ptr.push_back(new A);
 
    container_utils::clean(vec_ptr);
 
    std::cout << “############################################” << std::endl;
}
 
 

Download this code: container_clean.cpp