Re: Simulating reference variables using `alias this`

[Carl Sturtivant via Digitalmars-d]

On Wednesday, 10 May 2017 at 17:12:11 UTC, Carl Sturtivant wrote:
Here's the beginning of an interesting little experiment to 
simulate reference variables using `alias this` to disguise a 
pointer as a reference. Could add a destructor to set the 
pointer to null when a reference goes out of scope.

Here's a better version. Improvements? This can still behave as 
badly as a pointer, e.g. if returned from a function.

```
struct reference(T)
{
    T* ptr;
    this(ref T x)
    {
        ptr = &x;
    }
    ~this()
    {
        ptr = null;
    }
    import std.exception : enforce;

    ref T cnvrt() @property
    {
        enforce( ptr !is null);
        return *ptr;
    }
    ref T cnvrt(T x) @property
    {
        enforce( ptr !is null);
        return *ptr = x;
    }
    ref reference!T opAssign(T t)
    {
        enforce( ptr !is null);
        *ptr = t;
        return this;
    }
    ref reference!T opAssign(ref reference!T r)
    {
        enforce( ptr !is null && r.ptr !is null);
        *ptr = *r.ptr;
        return this;
    }
    alias cnvrt this;
}

void main()
{
    int i;
    auto ri = reference!int(i);
    auto ri2 = reference!int(ri);

    assert(ri.ptr==ri2.ptr);

    i = 99;
    assert(i==ri && i==ri2 && ri==ri2);

    ri = 100;
    assert(i==ri && i==ri2 && ri==ri2);

    ri2 = 101;
    assert(i==ri && i==ri2 && ri==ri2);

    int j = -1;
    auto rj = reference!int(j);

    ri = rj;

    assert(ri==rj);
    assert(ri.ptr!=rj.ptr);
}
```