Initialize class at given location

[drug007]

On 28.11.2025 22:32, Brother Bill wrote:
> On Friday, 28 November 2025 at 18:42:44 UTC, drug007 wrote:
>> On 28.11.2025 21:14, tzsz wrote:
>> In C++ it is called placement new. In D you should emplace class:
>>
> 
> This is quite helpful.  Could you provide another toy example where we 
> have abstract Vehicle class, then effective Car class derived from 
> Vehicle, then Toyota class derived from Car class. The Toyota class 
> needs to call Car constructor, which may need to call Vehicle 
> constructor, then complete its own constructor.
> Vehicle class has member of int speed (in Miles per hour), which will be 
> used in the example.  All classes have explicit constructors and 
> explicit destructors.
> 
> This example would complete the understanding of using emplace for me.
> Working examples that can be reproduced are the best teachers.
> 
> It is my understanding that using emplace as shown will make this class 
> pointer outside the scope of the GC.
> 
> Avoiding GC seems to be popular with Zig, Rust and other languages.
> It seems that D can play this game too.

It might look like this:

```D
import core.lifetime : emplace;
import std.stdio : writeln, writefln;
import std.experimental.allocator.mallocator : Mallocator;


abstract class Vehicle
{
     protected int speed;

     this(int initialSpeed)
     {
         this.speed = initialSpeed;
         writeln("Vehicle constructor called, speed: ", this.speed, " 
MPH.");
     }

     abstract void drive();

     ~this()
     {
         writeln("Vehicle destructor called.");
     }
}

class Car : Vehicle
{
     protected int wheels;

     this(int speed, int wheels)
     {
         super(speed); // Call Vehicle constructor
         this.wheels = wheels;
         writeln("Car constructor called, wheels: ", this.wheels);
     }

     override void drive()
     {
         writeln("A car is driving at ", speed, " MPH on ", wheels, " 
wheels.");
     }

     ~this()
     {
         writeln("Car destructor called.");
     }
}

class Toyota : Car
{
     protected string model;

     this(int speed, string model)
     {
         super(speed, 4); // Call Car constructor (which calls Vehicle's)
         this.model = model;
         writeln("Toyota constructor called, model: ", this.model);
     }

     // Toyota can use the drive method inherited from Car/Vehicle

     ~this()
     {
         writeln("Toyota destructor called.");
     }
}

void main()
{
     // Determine size needed for the concrete type we are emplacing 
(Toyota)
     enum size = __traits(classInstanceSize, Toyota);
     writeln("Size needed for Toyota instance: ", size, " bytes.");

     // Manually allocate memory using allocator, not C heap
     void[] rawMemory = Mallocator.instance.allocate(size);
     if (!rawMemory.ptr)
         throw new Exception("Out of memory!");
     writefln("Allocated raw memory address: %s, size: %s", 
rawMemory.ptr, rawMemory.length);

     // Using the slice above you can print the content of your instance
     writeln("\nUninitialized memory before Toyota instance construction");
     writefln("%(%02x %)\n", rawMemory);

     // Emplace the Toyota instance into the raw memory, calling its 
constructor
     // The constructors are called in order: Vehicle -> Car -> Toyota
     writeln("\n--- Emplacing the instance ---");
     auto myToyota = emplace!Toyota(cast(Toyota)rawMemory.ptr, 60, 
"Corolla");

     writeln("\nInitialized memory after Toyota instance construction");
     writefln("%(%02x %)\n", rawMemory);
     // it is offtopic but first 8 bytes are pointer to vtable,
     // next 8 bytes are so called monitor, so speed from Vehicle
     // is next 4 bytes and wheels amount is next 4 bytes,
     // next 8 bytes are length of the model name and
     // the last 8 bytes are the pointer to the model name

     // Use the instance
     writeln("\n--- Using the instance ---");
     myToyota.drive();
     myToyota.speed = 65; // Can modify inherited members
     myToyota.drive();

     writeln("\nInitialized memory after changing Toyota speed from 60 
to 65");
     writefln("%(%02x %)\n", rawMemory);

     // Manually destroy the object before freeing the memory
     writeln("\n--- Destroying the instance and freeing memory ---");
     // The destructors are called in reverse order: Toyota -> Car -> 
Vehicle
     destroy(myToyota);

     // Free the manually allocated raw memory
     Mallocator.instance.deallocate(rawMemory);
     writeln("Memory freed.");
}
```