57

I've seen code like this in a couple of old projects:

class Class {
    static void Method() {}
};

((Class*)0)->Method();

This code contains undefined behavior because it includes dereferencing a null pointer (no matter what happens afterwards). It really makes no sense - the cast is there to feed the type name to the compiler and whoever wrote the code above could have written this instead:

Class::Method();

and the latter would be okay.

Why would anyone write the former code? Is it a known idiom from some good old days or what?

Improve this question
13
  • 2
    I suspect this kind of thing comes from macros that can be used with regular or static methods. Commented Sep 8, 2014 at 7:32
  • 1
    I am not certain the call in itself is strictly doing any "dereferencing". Though that might happen in the function itself. Commented Sep 8, 2014 at 7:32
  • 2
    It's kind of like the fake dereferencing in the offsetof() macro that people wrote before it was added to the language. Commented Sep 8, 2014 at 7:33
  • 17
    It's obviously a bad thing to do - my best guess is that originally Method was not static (but didn't access any instance data) and someone used this hack to invoke it. Later someone else realised that Method needed to be static and changed it, but didn't fix all the places that it was being called from. Commented Sep 8, 2014 at 7:33
  • 2
    Its far more common to see a null pointer variable used with this. Ex: VC++ DevCon 1999, DonBox touted, CComObject<YourClass>* pObj = NULL; HRESULT hr = pObj->CreateInstance(&pObj); "You know you can do that, right?" Well, read this and decide which side of the fence you reside on. Its clear where Don hangs out. Commented Sep 8, 2014 at 7:46

1 Answer 1

Reset to default
66

Static member functions were added into C++ in 1989, in Release 2.0 of the AT&T C++ Language System (pre-standardisation). Prior to that, the static keyword could not be used to declare static member functions, so code authors used workarounds, principally the one you have observed of indirecting a null pointer.

In the Selected Readings accompanying version 2.0 of the AT&T C++ Language System, in section 1-22, Stroustrup writes:

It was also observed that nonportable code, such as:

((X*)0)->f();

was used to simulate static member functions. This trick is a time bomb because sooner or later someone will make an f() that is used this way virtual and the call will fail horribly because there is no X object at address zero. Even where f() is not virtual such calls will fail under some implementations of dynamic linking.

Your code was written to compile under Cfront 1.0 or by someone who was not aware at the time of the addition of static member functions to the language.

The annotation of the member function with static is indeed a puzzle, as Cheers and hth. - Alf has observed; Cfront 1.0 would have rejected that code with:

error:  member Method() cannot be static

so it cannot have been there initially. I think Potatoswatter is most likely correct; static was added at a later date to document and enforce the static method attribute of Method, once a C++ 2.0 compiler could be guaranteed to be available, but without the calling code being updated. To confirm this you'd need to interview the original programmer(s) or at least examine source control history (if any exists).

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

Why doesn't Stroustrup mention the more egregious problem of undefined behavior? He argues with implementation details.
@usr It goes without saying that the crash in practice is due to undefined behavior in theory.
@Potatoswatter No matter what f does, an optimizing compiler can treat the call as unreachable. This is frequently being done. A crash is not at all the only practical consequence. Deletion of code is another. That's why arguing with implementation details is inferior to just pointing out UB. The failure modes follow from the presence of UB.
@usr: Stroustrup couldn't argue about undefined behavior pre 1998, such as for code before 1989 (this code), because that would be meaningless. The language was only informally and partially defined then, by his book "The C++ Programming Language".
@Cheersandhth.-Alf Likely the client (function call) code is cruftier, and the library (class definition) was updated with static after it was introduced. Or, it's the product of two programmers, one of whom was anachronistic.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.