struct in class access

js.mdnq js_adddot+mdng at gmail.com
Sat Dec 8 22:54:25 PST 2012


Why can't a struct inside a class access the members of that 
class without a this pointer? It would seem natural to me that a 
nested struct should probably be special in that it is really 
just a special container to reduce clutter in the class.

class a {
    string v;
    struct b { void fun() { writeln(v); } }
    b bb;
}

should be semantically equivalent to

class a {
    string v;
    void bb.fun() { writeln(v); }
}

(and struct b does not have to include a "this" pointer since it 
is passed down)

I'm in need of using structs to wrap opAssign so I can override 
for each variable(instead of a special method for each field in 
the class, which adds clutter and prevents using `=` properly). 
But I also want to access the class container's members. (and 
without having to enlarge the struct)

It seems to me that the compiler should not have any difficult 
treating a struct method as a class method(passing the this ptr 
to it) but operating on struct's data.

What's the difference between

class a {
    int x;
}

and

class a {
    struct b { alias _x this; int _x; }
    b x;
}

? (and if be is made to be used inside the class only then it 
seems as if it's just basically no different than using the class 
alone except for some simplification(has it's own op's that one 
unfortunately can't keep distinct from the class align since they 
would overlap(although it would be nice).

e.g.,


class a {
    string Name;
    void opAssign(T q) { };      // classes opAssign

    //{{ Essentially a struct here
      int x;
      void opAssign_x(T q) { writeln(Name); };   // Somehow 
overrides = for x. ('structs' opAssign)
    //}}
}

and

class a {
    string Name;
    void opAssign(T q) { };
    struct b { alias _x this; int _x; void opAssign(T q) { 
writeln(Name); }; } // Unfortunately we can't access Name
    b x;
}

i.e., it would seem to me that the only difference in the method 
opAssign of the struct is the offsets of the member variables is 
different(one referenced to the start of the struct and the first 
references them to start of the class.

Therefor we shouldn't have any issues having properties from both 
the *true* nested struct and directly inlining it. i.e., we 
should be able to access outer members(the functionality when we 
inline the struct into the class) AND have multiple opAssign's(or 
any ops) per class that can be specified for any field(which is 
the functionality we get when we use the struct).

Essentially what it boils down to is that nested structs do 
contain a this pointer to the parent class, so why can't we use 
it? (it's just some offset difference between the struct and 
class)

I do realize that nested structs are not special in the current 
implementation AFAIK which to me, is a waste as they should be 
special. In any case, is there some other way to get the same 
behavior in D?

One might say why don't I use classes as it solves the problem 
directly BUT there is a ton of wasted overhead for simply 
wrapping values.

I would use template mixin's but the opAssigns would clash AFAIK. 
The struct encapsulation lets me get the correct opAssign 
behavior which is what I need but prevent me from accessing the 
outer class members which I should be able to do.










More information about the Digitalmars-d-learn mailing list