An interesting consequence of safety requirements

[Andrei Alexandrescu]

Something just dawned on me: in safe mode, struct static member 
functions will be preferred to struct non-static member functions.

Why?
Consider:

struct List(T) {
    T payload;
    List * next;

    void prepend(List * newNode) {
        newNode.next = &this;
    }
}

This code can't make it in safe mode because it takes the address of 
this. In general, the compiler must assume that you might have created a 
List object on the stack, e.g.:

List * someFun() {
    List local;
    List * lst = new List;
    local.prepend(lst);
    return lst;
}

Now even if there is no ostensible local address taking, the code is in 
error because it has escaped the address of a local.

So prepend() cannot be compiled. The way to make it compile in safe mode is:


struct List(T) {
    T payload;
    List * next;

    static void prepend(List * zis, List * newNode) {
        newNode.next = zis;
    }
}

Now the code compiles and is actually safe because it is impossible to 
pass the address of a local into prepend.

So get ready to use static a lot more ;o).


Andrei