Automatically Allocated Buffer Class. More...

#include <opencv2/core/utility.hpp>

Public Types
typedef const _Tp *	const_iterator
typedef const _Tp &	const_reference
typedef std::ptrdiff_t	difference_type
typedef _Tp *	iterator
typedef _Tp &	reference
typedef std::size_t	size_type
typedef _Tp	value_type

Public Member Functions
	AutoBuffer ()
	the default constructor
	AutoBuffer (const AutoBuffer< _Tp, fixed_size > &buf)
	the copy constructor
	AutoBuffer (size_t _size)
	constructor taking the real buffer size
	AutoBuffer (size_t _size, const _Tp &value)
	~AutoBuffer ()
	destructor. calls deallocate()
void	allocate (size_t _size)
	allocates the new buffer of size _size. if the _size is small enough, stack-allocated buffer is used
reference	back ()
const_reference	back () const
iterator	begin ()
const_iterator	begin () const
const_iterator	cbegin () const
const_iterator	cend () const
void	clear ()
_Tp *	data ()
	returns pointer to the real buffer, stack-allocated or heap-allocated
const _Tp *	data () const
	returns read-only pointer to the real buffer, stack-allocated or heap-allocated
void	deallocate ()
	deallocates the buffer if it was dynamically allocated
void	emplace_back (_Tp &&value)
bool	empty () const
iterator	end ()
const_iterator	end () const
reference	front ()
const_reference	front () const
	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	pop_back ()
void	push_back (_Tp &&value)
void	push_back (const _Tp &value)
void	resize (size_t _size)
	resizes the buffer and preserves the content
size_t	size () const
	returns the current buffer size

Protected Attributes
_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

Detailed Description

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

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
   ...
}