#include "stdafx.h"
#include <vector> 
#include <list> 
#include <iostream> 
#include <algorithm> 

using namespace std;


struct DeleteObj
{
   template<class T>
   void operator()( T& p )
   {
      delete p;
   }
};

struct DeleteAndNullObj
{
   template<class T>
   void operator()( T& p )
   {
      delete p;
      p =0;
   }
};

struct DeleteAndSetBytePattern
{
   template<class T>
   void operator()( T& p )
   {
      delete p;
      p =reinterpret_cast<T>(0xDEADBEEF);
   }
};

struct ContainerDelete
{
    template<class T>
    void Delete( T& container )
    {
        std::for_each( container.begin(), container.end(), DeleteObj() );
    }
};

struct ContainerDeleteAndNull
{
    template<class T>
    void Delete( T& container )
    {
        std::for_each( container.begin(), container.end(), DeleteAndNullObj() );
    }
};

struct ContainerDeleteAndSetBytePattern
{
    template<class T>
    void Delete( T& container )
    {
        std::for_each( container.begin(), container.end(), DeleteAndSetBytePattern() );
    }
};


template<
          class   Elem
         ,class   Container = vector< Elem >
         ,bool bDeleteAlways = true
         ,class   DeletionPolicy = ContainerDelete
      >

class SmartContainer : public DeletionPolicy
{
public:
// typedefs expose the member containers types as our own

   typedef Container::iterator iterator;
   typedef Container::const_iterator const_iterator;

   SmartContainer(){};
   SmartContainer(const int i_sz) : cont_(i_sz) {};

   ~SmartContainer()
   {
      if(bDeleteAlways)
      {
         Delete( cont_ );
      }
   }

// exposure of member container functionality
   void push_back(Elem val) { cont_.push_back(val);}
   iterator begin(){ return cont_.begin();   }
   iterator end()  { return cont_.end();     }


// extending its interface to make it more useful
   void delete_objects()
   {
      if( ! bDeleteAlways)
      {
         Delete(cont_);
      }
   }

private:
   Container cont_;
};

Driver

Home