Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

std.experimental.allocator.mallocator

The C heap allocator.
struct Mallocator;
The C heap allocator.
Examples:
auto buffer = Mallocator.instance.allocate(1024 * 1024 * 4);
scope(exit) Mallocator.instance.deallocate(buffer);
//...
enum uint alignment;
The alignment is a static constant equal to platformAlignment, which ensures proper alignment for any D data type.
shared const pure nothrow @nogc @trusted void[] allocate(size_t bytes);

shared const pure nothrow @nogc @system bool deallocate(void[] b);

shared const pure nothrow @nogc @system bool reallocate(ref void[] b, size_t s);
Standard allocator methods per the semantics defined above. The deallocate and reallocate methods are @system because they may move memory around, leaving dangling pointers in user code. Somewhat paradoxically, malloc is @safe but that's only useful to safe programs that can afford to leak memory allocated.
static shared Mallocator instance;
Returns the global instance of this allocator type. The C heap allocator is thread-safe, therefore all of its methods and it itself are shared.
struct AlignedMallocator;
Aligned allocator using OS-specific primitives, under a uniform API.
Examples:
auto buffer = AlignedMallocator.instance.alignedAllocate(1024 * 1024 * 4,
    128);
scope(exit) AlignedMallocator.instance.deallocate(buffer);
//...
enum uint alignment;
The default alignment is platformAlignment.
shared nothrow @nogc @trusted void[] allocate(size_t bytes);
Forwards to alignedAllocate(bytes, platformAlignment).
shared nothrow @nogc @trusted void[] alignedAllocate(size_t bytes, uint a);
Uses posix_memalign on Posix and __aligned_malloc on Windows.
shared nothrow @nogc @system bool deallocate(void[] b);
Calls free(b.ptr) on Posix and __aligned_free(b.ptr) on Windows.
shared nothrow @nogc @system bool reallocate(ref void[] b, size_t newSize);

shared nothrow @nogc @system bool alignedReallocate(ref void[] b, size_t s, uint a);
Forwards to alignedReallocate(b, newSize, platformAlignment). Should be used with blocks obtained with allocate otherwise the custom alignment passed with alignedAllocate can be lost.
static shared AlignedMallocator instance;
Returns the global instance of this allocator type. The C heap allocator is thread-safe, therefore all of its methods and instance itself are shared.