opencv 2.2.0

- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Types | Public Member Functions | Protected Attributes | List of all members
cv::AutoBuffer< _Tp, fixed_size > Class Template Reference

`#include <core.hpp>`

## Public Types
typedef _Tp | value_type

## Public Member Functions
void | allocate (size_t _size)
| allocates the new buffer of size _size. if the _size is small enough, stack-allocated buffer is used
| AutoBuffer ()
| the default contructor
| AutoBuffer (size_t _size)
| constructor taking the real buffer size
void | deallocate ()
| deallocates the buffer if it was dynamically allocated
| operator _Tp * ()
| returns pointer to the real buffer, stack-allocated or head-allocated
| operator const _Tp * () const
| returns read-only pointer to the real buffer, stack-allocated or head-allocated
| ~AutoBuffer ()
| destructor. calls deallocate()

## Protected Attributes
_Tp | buf [fixed_size]
| pre-allocated buffer
_Tp * | ptr
| pointer to the real buffer, can point to buf if the buffer is small enough
size_t | size
| size of the real buffer

## Detailed Description

### template<typename _Tp, size_t fixed_size = 4096/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, 1000> buf; // 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
...
}

## Member Typedef Documentation

template<typename _Tp, size_t fixed_size = 4096/sizeof(_Tp)+8>

typedef _Tp cv::AutoBuffer< _Tp, fixed_size >::value_type

## Constructor & Destructor Documentation

template<typename _Tp , size_t fixed_size>

cv::AutoBuffer< _Tp, fixed_size >::AutoBuffer | ( |  | ) |
| inline

the default contructor

template<typename _Tp , size_t fixed_size>

cv::AutoBuffer< _Tp, fixed_size >::AutoBuffer | ( | size_t | _size | ) |
| inline

constructor taking the real buffer size

template<typename _Tp , size_t fixed_size>

cv::AutoBuffer< _Tp, fixed_size >::~AutoBuffer | ( |  | ) |
| inline

destructor. calls deallocate()

## Member Function Documentation

template<typename _Tp , size_t fixed_size>

void cv::AutoBuffer< _Tp, fixed_size >::allocate | ( | size_t | _size | ) |
| inline

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

template<typename _Tp , size_t fixed_size>

void cv::AutoBuffer< _Tp, fixed_size >::deallocate | ( |  | ) |
| inline

deallocates the buffer if it was dynamically allocated

template<typename _Tp , size_t fixed_size>

cv::AutoBuffer< _Tp, fixed_size >::operator _Tp * | ( |  | ) |
| inline

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

template<typename _Tp , size_t fixed_size>

cv::AutoBuffer< _Tp, fixed_size >::operator const _Tp * | ( |  | ) | const
| inline

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

## Member Data Documentation

template<typename _Tp, size_t fixed_size = 4096/sizeof(_Tp)+8>

_Tp cv::AutoBuffer< _Tp, fixed_size >::buf[fixed_size]
| protected

pre-allocated buffer

template<typename _Tp, size_t fixed_size = 4096/sizeof(_Tp)+8>

_Tp* cv::AutoBuffer< _Tp, fixed_size >::ptr
| protected

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

template<typename _Tp, size_t fixed_size = 4096/sizeof(_Tp)+8>

size_t cv::AutoBuffer< _Tp, fixed_size >::size
| protected

size of the real buffer

The documentation for this class was generated from the following files:

- /usr/obj/OpenCV-2.2.0/OpenCV-2.2.0/modules/core/include/opencv2/core/core.hpp
- /usr/obj/OpenCV-2.2.0/OpenCV-2.2.0/modules/core/include/opencv2/core/operations.hpp