Initialization vs Assignment

["Luís]

Hi,

Most of the time my D code has been high-level, so I had never 
considered the following issue. Imagine you have a struct A as a 
member of a class/struct X (here a struct, to ensure the dtor is 
called):

     struct A
     {
         int v;

         this(int v)
         {
             this.v = v*2;
         }

         ~this()
         {
             writefln("~A(%d)", v);
         }
     }

     struct X
     {
         A a;

         this(int v)
         {
             a = A(v);
             writeln("-");
         }
     }

     void main()
     {
         X x = X(42);
     }

Output:

     ~A(0)
     -
     ~A(84)

That is, because we don't have C++'s colon initialization syntax, 
we are paying the cost of initializing (and then destroying) X.a 
before we assign to it with "a = A(v)" in X's ctor. This seems to 
be the case even with @disable A.this(), which here does not seem 
to do anything (does not prevent the default/implicit 
initialization of X.a, before it is assigned A(v) ).

If C++ distinguishes between initialization and assignment to 
avoid this issue, is there a reason why D can avoid making the 
distinction? That is a performance issue. How about correctness? 
For instance:

     struct A
     {
         void* mem;

         @disable this();

         this(int v)
         {
             mem = malloc(v);
         }

         ~this()
         {
             free(mem);
         }
     }

Now we can't have an A as a member of X? (it would free a null 
pointer)

How have you solved these cases? Do you change it to a PIMPL? 
What if that's not desirable? What if you don't want to break 
encapsulation / cleanliness too much? Etc. Is there a good 
general solution for this issue?