• js.mdnq (55/55) Nov 29 2012 Reading 'the book' and it states that D does not allow one to

"js.mdnq" <js_adddot+mdng gmail.com> writes:

Reading 'the book' and it states that D does not allow one to 
nest construction calls that are not "complete".

e.g.,

this()
{
    if (x > 1) { this(x); }
}

will fail.

First, I do not know why this is required. It seems to me it 
would be better to allow one optionally use another constructor 
if it is desired rather than forcing all paths to use it.

Also, It is easy to avoid this by alaising "this(...)"(using 
member functions that this(...) wraps). This, then is exactly the 
same semantically above but avoids the error:

this()
{
    if (x > 1) { thiswrapper(x); }
}

this(double x) { thiswrapper(x); }


(so, the constraint in D only increases code bloat as far as I 
can tell and, hence, unnecessary)


Second, steaming from this issue with constructors, how can we 
get the address of a constructor, or alternative, store it in a 
delegate/function:

class Test
{
    static void function(Test, double) thiswrapper;

    this()
    {
       thiswrapper = ????this(double);
       if (x > 1) { thiswrapper(x); }
    }

    this(double x) { }
}


The point of the example code(only an example, I know it is 
rather useless but so are babies, right?) is to simply do the 
same the previous example but sort of backwards. The previous 
example has thiswrapper being wrapped by this(double) while in 
this case thiswrapper wraps this(double). They will will have 
virtually identical semantics with different syntax.

The second case allows us to solve the original problem a bit 
more logical. (in fact, if we had some type of "multi-function 
pointer" that allowed overloads we could, say, assign all the 
constructor functions to thiswrapper and let the compiler choose 
the appropriate one)

In any case the second question involves assigning functions to 
function pointers/delegates, specifically the constructor 
functions.

I guess it would be the a similar problem if I wanted to assign a 
function pointer to a member of a class from a pointer to that 
class.

class Test { void mymethod(...){} void mymethod(....){}}

void function(...) mymethodptr = t->mymethod; (which should be 
the same as Test.mymethod?)

Thanks