C++ static const access through a NULL pointer [duplicate]

Answer 1

Even if it worked it is awful code.

In serious programming you code not only for yourself, but also for others who will maintain your code. Playing tricks like this must be avoided, because you respect your colleagues.

One consequence of this code: whether the pointer is NULL or not is even not at question, but it implies that this member kType may not be a plain non-static member of the class. Sometimes classes are big (this is evil too) and one cannot always recheck the definition of each and every variable.

Be rigorous. And call all your static members only this way:

Foo::kType

Another possibility is to follow a coding convention that let know that the member is static, for example, a s_ prefix for all classes static members:

Foo::s_kType

Answer 2

I believe that the actual value of the type is not used at all when calling

bar->kType

since kType is static, and bar is of type Foo it is the same as calling

Foo::kType

which you should really be doing anyway for clarity.

Calling bar->kType gives a compiler warning on most platforms for this reason.

Answer 3

You can use a pointer (or other expression) to access a static member; however, doing so through a NULL pointer unfortunately is officially undefined behavior. From 9.4/2 "Static members":

A static member s of class X may be referred to using the qualified-id expression X::s; it is not necessary to use the class member access syntax (5.2.5) to refer to a static member. A static member may be referred to using the class member access syntax, in which case the object-expression is evaluated.

Based on the example that follows:

class process {
public:
    static void reschedule();
};

process& g();

void f()
{
    process::reschedule();   // OK: no object necessary
    g().reschedule();        // g() is called
}

The intent is to allow you to ensure that functions will be called in this scenario.

Answer 4

There is a higher rule so to speak which basically says - don't even think about compiling things that are provably not used. Advanced template programming depends on this a lot, so even if it might be a bit gray-zonish when a compiler clearly sees that the result of a construct is not used it's just going to eliminate it. Especially when it's provably safe like in this case.

You may want to try a few variants if you want - like making pointer a param of a function, result of a function, leaving a pointer uninitialized (best chance for triggering compiler complaint), doing a straight cast of 0 (best chance of being conplaint-free).

Answer 5

Apart from the issue about accessing through the NULL pointer, there is another subtle issue in the code

$9.4.2/2 - "The declaration of a static data member in its class definition is not a definition and may be of an incomplete type other than cv-qualified void. The definition for a static data member shall appear in a namespace scope enclosing the member’s class definition."

$9.4.2/4- "If a static data member is of const integral or const enumeration type, its declaration in the class definition can specify a constant-initializer which shall be an integral constant expression (5.19). In that case, the member can appear in integral constant expressions. The member shall still be defined in a namespace scope if it is used in the program and the namespace scope definition shall not contain an initializer."

class Foo { 
public: 
 static const int kType = 42; 
}; 

int const Foo::kType;

void Func() { 
 Foo *bar = NULL; 
 int x = bar->kType; 
 putc(x, stderr); 
}

So, yet one more reason for UB in the OP code.