template<class Type>
class Buffer
{
    Type* m_buf;
    size_t m_size;
    
public:

    Buffer<Type>() : m_buf(NULL), m_size(0)
    {

    }

    Buffer<Type>(size_t aSize) : m_buf(NULL), m_size(aSize)
    {
        Realloc(aSize);
    }

    Buffer<Type>(const Buffer<Type>& arg)
    {
        *this = arg;
    }

    ~Buffer<Type>()
    {
        if(m_buf)
        {
            delete [] m_buf;
            m_buf=NULL;
        }
        m_size = 0;
    }

    size_t size() const 
    {
        return m_size;
    }

    Type* data()
    {
        return m_buf;
    }

    const Type* data() const
    {
        return m_buf;
    }

    void Fill(const Type& val)
    {
        for(size_t c=0; c<size(); c++)
        {
            m_buf[c] = val;
        }
    }

    void FillMem(int val)
    {
        if(!m_buf)
        {
            throw(NULL);
        }
        memset(m_buf, val, sizeof(Type) * size() );
    }

    Type* Realloc( size_t new_size )
    {
        if( m_buf )
        {
            delete [] m_buf;
            m_buf = NULL;
        }

        m_size = new_size;
        m_buf = new Type [ m_size ] ;
        return data();
    }

    void operator = ( const Buffer<Type>& arg )
    {
        Realloc(arg.size());
        for(size_t c=0; c<size(); c++)
        {
            m_buf[c] = arg.data()[c];
        }

    }


};