template class cv::AutoBuffer

Overview

Automatically Allocated Buffer Class. More…

#include <utility.hpp>

template <
    typename _Tp,
    size_t fixed_size = 1024/sizeof(_Tp)+8
    >
class AutoBuffer
{
public:
    // typedefs

    typedef _Tp value_type;

    // construction

    AutoBuffer();
    AutoBuffer(size_t _size);
    AutoBuffer(const AutoBuffer<_Tp, fixed_size>& buf);

    // methods

    void
    allocate(size_t _size);

    void
    deallocate();

    operator _Tp *();
    operator const _Tp *() const;

    AutoBuffer<_Tp, fixed_size>&
    operator=(const AutoBuffer<_Tp, fixed_size>& buf);

    void
    resize(size_t _size);

    size_t
    size() const;

protected:
    // fields

    _Tp buf[(fixed_size > 0) ? fixed_size :1];
    _Tp* ptr;
    size_t sz;
};

Detailed Documentation

Automatically Allocated Buffer Class.

The class is used for temporary buffers in functions and methods. If a temporary buffer is usually small (a few K’s of memory), but its size depends on the parameters, it makes sense to create a small fixed-size array on stack and use it if it’s large enough. If the required buffer size is larger than the fixed size, another buffer of sufficient size is allocated dynamically and released after the processing. Therefore, in typical cases, when the buffer size is small, there is no overhead associated with malloc()/free(). At the same time, there is no limit on the size of processed data.

This is what AutoBuffer does. The template takes 2 parameters - type of the buffer elements and the number of stack-allocated elements. Here is how the class is used:

void my_func(const cv::Mat& m)
{
   cv::AutoBuffer<float> buf(1000); // create automatic buffer containing 1000 floats

   buf.allocate(m.rows); // if m.rows <= 1000, the pre-allocated buffer is used,
                         // otherwise the buffer of "m.rows" floats will be allocated
                         // dynamically and deallocated in cv::AutoBuffer destructor
   ...
}

Fields

_Tp buf[(fixed_size > 0) ? fixed_size :1]

pre-allocated buffer. At least 1 element to confirm C++ standard requirements

_Tp* ptr

pointer to the real buffer, can point to buf if the buffer is small enough

size_t sz

size of the real buffer

Construction

AutoBuffer()

the default constructor

AutoBuffer(size_t _size)

constructor taking the real buffer size

AutoBuffer(const AutoBuffer<_Tp, fixed_size>& buf)

the copy constructor

Methods

void
allocate(size_t _size)

allocates the new buffer of size _size. if the _size is small enough, stack-allocated buffer is used

void
deallocate()

deallocates the buffer if it was dynamically allocated

operator _Tp *()

returns pointer to the real buffer, stack-allocated or heap-allocated

operator const _Tp *() const

returns read-only pointer to the real buffer, stack-allocated or heap-allocated

AutoBuffer<_Tp, fixed_size>&
operator=(const AutoBuffer<_Tp, fixed_size>& buf)

the assignment operator

void
resize(size_t _size)

resizes the buffer and preserves the content

size_t
size() const

returns the current buffer size