Function std.experimental.allocator.make
Dynamically allocates (using alloc
) and then creates in the memory
allocated an object of type T
, using args
(if any) for its
initialization. Initialization occurs in the memory allocated and is otherwise
semantically the same as T(args)
.
(Note that using alloc
creates a pointer to an (empty) array
of T
s, not an array. To use an allocator to allocate and initialize an
array, use alloc
described below.)
auto make(T, Allocator, A...)
(
auto ref Allocator alloc,
auto ref A args
);
Parameters
Name | Description |
---|---|
T | Type of the object being created. |
alloc | The allocator used for getting the needed memory. It may be an object
implementing the static interface for allocators, or an IAllocator
reference. |
args | Optional arguments used for initializing the created object. If not present, the object is default constructed. |
Returns
If T
is a class type, returns a reference to the created T
object. Otherwise, returns a T*
pointing to the created object. In all
cases, returns null
if allocation failed.
Throws
If T
's constructor throws, deallocates the allocated memory and
propagates the exception.
Example
// Dynamically allocate one integer
const int* p1 = theAllocator .make!int;
// It's implicitly initialized with its .init value
writeln(*p1); // 0
// Dynamically allocate one double, initialize to 42.5
const double* p2 = theAllocator .make!double(42.5);
writeln(*p2); // 42.5
// Dynamically allocate a struct
static struct Point
{
int x, y, z;
}
// Use the generated constructor taking field values in order
const Point* p = theAllocator .make!Point(1, 2);
assert(p .x == 1 && p .y == 2 && p .z == 0);
// Dynamically allocate a class object
static class Customer
{
uint id = uint .max;
this() {}
this(uint id) { this .id = id; }
// ...
}
Customer cust = theAllocator .make!Customer;
assert(cust .id == uint .max); // default initialized
cust = theAllocator .make!Customer(42);
writeln(cust .id); // 42
// explicit passing of outer pointer
static class Outer
{
int x = 3;
class Inner
{
auto getX() { return x; }
}
}
auto outer = theAllocator .make!Outer();
auto inner = theAllocator .make!(Outer .Inner)(outer);
writeln(outer .x); // inner.getX