Re: struct vs. class, int vs. char.

[Denis Koroskin]

On Wed, 29 Apr 2009 06:09:49 +0400, Daniel Keep <daniel.keep.li...@gmail.com> 
wrote:


Denis Koroskin wrote:
...

Scope stack-allocating is an optimisation.  It doesn't guarantee it
because that it's the point of scope.

Given that you're hung-up about stack allocation, I can't imagine how
you'd implement scope as a template.  Hell, I can't imagine how you'd
implement Scope as a template for *any* of its behaviours.

class Foo
{
    Scope!(Bar) _bar;
}

How do you guarantee deterministic destruction when it's inside a
non-deterministic construct?

  -- Daniel

Is that a challenge?

import std.stdio;

class Foo
{       
   this(int i, int j, int k) {
       writeln("Foo.this(): ", i, j, k);
   }
        
   ~this() {
       writeln("Foo.~this()");
   }
}

struct Scope(T)
{
   this(Args...)(Args args)
   {
       _data[] = T.classinfo.init[]; // shouldn't be needed
       __get.__ctor(args);
   }
        
   ~this()
   {
       __get.__dtor();
   }

   alias __get this;
        
   T __get()
   {
       return cast(T)_data.ptr;
   }

   static assert(is(T == class));
   
   private byte[__traits(classInstanceSize, T)] _data;
   //private byte[__traits(classInstanceSize, T)] _data = T.classinfo.init; // 
bug: doesn't work
}

void main()
{
   auto foo = Scope!(Foo)(1, 2, 3);
}

One more bug-o-feature is that Scope.ctor is not called when args set is empty:

auto foo = Scope!(Foo)(); // no Scope.__ctor is called and thus underlying Foo instance 
is left uninitialized. I never understood a rationale behind this "feature". I 
believe it's a hole.