|
| | HeapBlock ()=default |
| template<typename SizeType, std::enable_if_t< std::is_convertible< SizeType, int >::value, int > = 0> |
| | HeapBlock (SizeType numElements) |
| template<typename SizeType, std::enable_if_t< std::is_convertible< SizeType, int >::value, int > = 0> |
| | HeapBlock (SizeType numElements, bool initialiseToZero) |
| | ~HeapBlock () |
| | HeapBlock (HeapBlock &&other) noexcept |
| HeapBlock & | operator= (HeapBlock &&other) noexcept |
| template<class OtherElementType, bool otherThrowOnFailure, typename = AllowConversion<OtherElementType>> |
| | HeapBlock (HeapBlock< OtherElementType, otherThrowOnFailure > &&other) noexcept |
| template<class OtherElementType, bool otherThrowOnFailure, typename = AllowConversion<OtherElementType>> |
| HeapBlock & | operator= (HeapBlock< OtherElementType, otherThrowOnFailure > &&other) noexcept |
| | operator ElementType * () const noexcept |
| ElementType * | get () const noexcept |
| ElementType * | getData () const noexcept |
| | operator void * () const noexcept |
| | operator const void * () const noexcept |
| ElementType * | operator-> () const noexcept |
| template<typename IndexType> |
| ElementType & | operator[] (IndexType index) const noexcept |
| template<typename IndexType> |
| ElementType * | operator+ (IndexType index) const noexcept |
| bool | operator== (const ElementType *otherPointer) const noexcept |
| bool | operator!= (const ElementType *otherPointer) const noexcept |
| template<typename SizeType> |
| void | malloc (SizeType newNumElements, size_t elementSize=sizeof(ElementType)) |
| template<typename SizeType> |
| void | calloc (SizeType newNumElements, const size_t elementSize=sizeof(ElementType)) |
| template<typename SizeType> |
| void | allocate (SizeType newNumElements, bool initialiseToZero) |
| template<typename SizeType> |
| void | realloc (SizeType newNumElements, size_t elementSize=sizeof(ElementType)) |
| void | free () noexcept |
| template<bool otherBlockThrows> |
| void | swapWith (HeapBlock< ElementType, otherBlockThrows > &other) noexcept |
| template<typename SizeType> |
| void | clear (SizeType numElements) noexcept |
template<class ElementType, bool throwOnFailure = false>
class juce::HeapBlock< ElementType, throwOnFailure >
Very simple container class to hold a pointer to some data on the heap.
When you need to allocate some heap storage for something, always try to use this class instead of allocating the memory directly using malloc/free.
A HeapBlock<char> object can be treated in pretty much exactly the same way as an char*, but as long as you allocate it on the stack or as a class member, it's almost impossible for it to leak memory.
It also makes your code much more concise and readable than doing the same thing using direct allocations,
E.g. instead of this:
int* temp = (
int*)
malloc (1024 *
sizeof (
int));
memcpy (temp, xyz, 1024 *
sizeof (
int));
temp = (
int*)
calloc (2048 *
sizeof (
int));
temp[0] = 1234;
memcpy (foobar, temp, 2048 *
sizeof (
int));
void malloc(SizeType newNumElements, size_t elementSize=sizeof(ElementType))
Definition juce_HeapBlock.h:252
void free() noexcept
Definition juce_HeapBlock.h:300
void calloc(SizeType newNumElements, const size_t elementSize=sizeof(ElementType))
Definition juce_HeapBlock.h:263
memcpy(hh, h, RAND_HEAD_LEN)
..you could just write this:
memcpy (temp, xyz, 1024 *
sizeof (
int));
temp.calloc (2048);
temp[0] = 1234;
memcpy (foobar, temp, 2048 *
sizeof (
int));
friend class HeapBlock
Definition juce_HeapBlock.h:342
The class is extremely lightweight, containing only a pointer to the data, and exposes malloc/realloc/calloc/free methods that do the same jobs as their less object-oriented counterparts. Despite adding safety, you probably won't sacrifice any performance by using this in place of normal pointers.
The throwOnFailure template parameter can be set to true if you'd like the class to throw a std::bad_alloc exception when an allocation fails. If this is false, then a failed allocation will just leave the heapblock with a null pointer (assuming that the system's malloc() function doesn't throw).
- See also
- Array, OwnedArray, MemoryBlock
@tags{Core}
template<class ElementType, bool throwOnFailure = false>
template<typename SizeType>
| void juce::HeapBlock< ElementType, throwOnFailure >::malloc |
( |
SizeType | newNumElements, |
|
|
size_t | elementSize = sizeof (ElementType) ) |
|
inline |
Allocates a specified amount of memory.
This uses the normal malloc to allocate an amount of memory for this object. Any previously allocated memory will be freed by this method.
The number of bytes allocated will be (newNumElements * elementSize). Normally you wouldn't need to specify the second parameter, but it can be handy if you need to allocate a size in bytes rather than in terms of the number of elements.
The data that is allocated will be freed when this object is deleted, or when you call free() or any of the allocation methods.
1.16.1