Postblit constructor

[Simen Kjærås]

On Wednesday, 28 February 2018 at 18:23:04 UTC, Jiyan wrote:
> The nodes are only allocated over malloc(). So i have to take 
> care of the initialisation myself.
> The problem is, that i found out by debugging, that it seems 
> that when i call val.opAssign(op) in constructNodeFrom(), there 
> isn't any postblit constructor called in there, the struct 
> seems just to get copied by a memcpy, can that be? Or is it a 
> bug? Shouldn't the postblit constructor get called there?

I'm not sure what you're expecting. The postblit is called when 
an operation results in there being two copies of something:

import std.stdio;

struct S {
     this(this) {
         writeln("Postblit!");
     }
}

S test() {
     return S.init;
}

void test2(S s) {}

unittest {
     S s1;
     writeln("Copy construction:");
     S s2 = s1; // There's now two copies of s, so postblit is 
called.
     writeln("Copy assignment:");
     s2 = s1;   // Again there are two copies, so postblit again.
     writeln("opAssign:");
     s2.opAssign(s1); // And one more time.
     writeln("Function call:");
     test2(s1); // And finally.
     writeln("Move construction:");
     s2 = test(); // This time, only one copy exists, so postblit 
is not called.
}

In each of these cases the values are first copied using memcpy 
or the like, then postblit is called in the first four cases. In 
the last case the value is moved from test() to s2, and so 
there's only ever one copy, and no postblit is necessary.

For more details, we can add a destructor:

import std.stdio;

struct S {
     int n;
     this(this) {
         writeln("Postblit!");
     }
     ~this() {
         writeln("~this");
     }
}

S test() {
     return S.init;
}

void test2(S s) {}

unittest {
     S s1;
     writeln("Copy construction:");
     S s2 = s1;
     writeln("Copy assignment:");
     s2 = s1;
     writeln("opAssign:");
     s2.opAssign(s1);
     writeln("Function call:");
     test2(s1);
     writeln("Move construction:");
     s2 = test();
     writeln("Done.");
}

And the output:

Copy construction:
Postblit!          // Called from s2.

Copy assignment:
Postblit!          // Called from s2.
~this              // Temporary copy of s2.

opAssign:
Postblit!          // Called from s2.
~this              // Temporary copy of s2.

Function call:
Postblit!          // Called from temporary created to be 
function argument.
~this              // The same temporary. Destroyed when test2() 
returns.

Move construction:
~this              // Temporary copy of s2.

Done.
~this              // s2 going out of scope.
~this              // s1 going out of scope.

It might seem weird that s2's destructor is called after the 
postblit is called. This is because a temporary copy of s2 is 
created, so that if the postblit throws, the original values are 
copied back, and everything's still in a valid state.

As we can see from this annotated output, a call resulting in a 
postblit (e.g. s2 = s;) is lowered to essentially this code:

S temp; // Create temporary.
memcpy(temp, s2, S.sizeof); // Fill temporary with values from s2.
memcpy(s2, s, S.sizeof); // Copy data from s to s2.
try {
     s2.__postblit(); // Call postblit.
     temp.__dtor(); // Destroy temporary.
} catch (Throwable) {
     memcpy(s2, temp, S.sizeof); // If postblit failed, copy 
temporary back.
}

--
   Simen