Node:Memory Handling Primitives, Next:Bibliography, Previous:Adaptors, Up:Top

Memory Handling Primitives

T* allocate (ptrdiff_t n, T*)

Function

To obtain a typed pointer to an uninitialized memory buffer of a given size the following function is defined: template inline T* allocate(ptrdiff_t n, T*); // n >= 0 The size (in bytes) of the allocated buffer is no less than n*sizeof(T). For every memory model there is a corresponding allocate template function defined with the first argument type being the distance type of the pointers in the memory model.

For example, if a compilation system supports __huge pointers with the distance type being long long, the following template function is provided:

template 
inline T __huge* allocate(long long n, T __huge *);

deallocate (T* buffer)	Function
construct (T1* p, const T2& value)	Function
destroy (T* pointer)	Function

Also, the following functions are provided:

template 
inline void deallocate(T* buffer);

template 
inline void construct(T1* p, const T2& value) {
    new (p) T1(value);
}

template 
inline void destroy(T* pointer) {
    pointer->~T();
}

deallocate frees the buffer allocated by allocate. For every memory model there are corresponding deallocate, construct and destroy template functions defined with the first argument type being the pointer type of the memory model.

pair<T*, ptrdiff_t> get_temporary_buffer (ptrdiff_t n, T*)	Function
void return_temporary_buffer (T* p)	Function

template 
pair get_temporary_buffer(ptrdiff_t n, T*);

template 
void return_temporary_buffer(T* p);

get_temporary_buffer finds the largest buffer not greater than n*sizeof(T), and returns a pair consisting of the address and the capacity (in the units of sizeof(T)) of the buffer. return_temporary_buffer returns the buffer allocated by get_temporary_buffer.