On Friday 03 September 2010 13:22:51 JMRyan wrote:
> I wouldn't have thought of "this" representing an lvalue. However, the
> following absurdity compiles and executes flawlessly. Just don't
> uncomment the assignment to y.i!
>
> class Yikes
> {
> int i;
> this() { this = null; }
> }
>
>
> void main()
> {
> auto y = new Yikes();
> // y.i = 0;
> }
>
> Is this a bug in the compiler (v.2.047)? Am I missing something in
> thinking it shouldn't be?
Of course, this is an lvalue.
1. Think about a struct for a moment, rather than a class. It's a value type.
Assigning to this inside a struct would change the struct's value. In some
circumstances, it would make perfect sense to do this. Assigning it to the
struct's init property to reset it would be a prime example.
2. Think about what a member function _really_ looks like. The member function
printM() in this class here
class A
{
int _x;
void printMe()
{
writeln(x);
}
}
really looks like this
void printMe(A this, printMe())
{
writeln(this.x);
}
If you were to set this to null in printMe(), what would it do? Nothing. You
just set a function parameter to null. Sure, after that, this be null _within
that function_, but it shouldn't be null after that that because the actual
object that this points to still exists, and when its reference gets passed to
other member functions, those won't be null, because you just set the local
variable to null. For instance, this program runs just fine:
import std.stdio;
class A
{
int _x;
this(int x)
{
_x = x;
}
void print()
{
writeln(_x);
}
void nullifyMe()
{
this = null;
}
}
void main()
{
auto a = new A(13);
a.print();
a.nullifyMe();
a.print();
}
It prints
13
13
Now, _your_ program bombs. However, I believe that that's because you assigned
null to this in the _constructor_. My guess is that internally, your
constructor
looks something like this:
Yikes this(Yikes this)
{
this = null;
return this;
}
When this is called, its member variables (namely i) have been initialized, and
its initial state is passed to the constructor to further do whatever stuff
that
you want your constructor to do. It then likely return null, which is what you
get from new() and is what is assigned to your local variable y. So, y is then
null. The Yikes object that you just created still exists. It's floating around
in memory. It's just that you can't get at it. If you try this instead:
import std.stdio;
Yikes global;
class Yikes
{
int i;
this() { global = this; this = null; }
}
void main()
{
auto y = new Yikes();
global.i = 1;
writeln(global.i);
}
it works and prints 1. You could even get rid of the "auto y = " part.
So, this is most definitely an lvalue. It's a bit stupid to assign null to it -
especially in the constructor - but it makes perfect sense that it works. And
in
some circumstances, it makes perfect sense to do so (though not with classes
since all it would ever affect would be the local variable and any member
functions that called from that member function).
- Jonathan M Davis
