C++ - Why static member function can't be crea

Question

Today I got a problem. I am in the need of a static member function, const is not a must but a better. But, I didn't succeed in my efforts. Can anybody say why or how?

Answer 1

It is unfortunate that C++ doesn't accept it as per design but logically there are few use cases in which it validates well.

A function which is class level valid(static) might not change any static data, may be it will just query data should be const. May be it should be like

if(Object)
    MakeThisConstant()
else
    MakeStaticDataConstant() // Only in the scope but static data cannot be constant so may be it should in some scenarios

Answer 2

I agree with your question, but unfortunately the C++ is designed that way. For example:

class A {
  int i;         //<--- accessed with 'this'
  static int s;  //<---- accessed without 'this'
public:
  static void foo ()  const // <-- imaginary const
  {}
};

As of today, the const is considered in context of this. In a way, it's narrow. It can be made broader by applying this const beyond this pointer.
i.e. the "proposed" const, which may also apply to static functions, will restrict the static members from any modification.

In the example code, if foo() can be made const, then in that function, A::s cannot be modified. I can't see any language side effects, if this rule is added to standard. On the contrary, it's amusing that why such rule doesn't exist!

Answer 3

Without getting into the details, it's because there may or may not be an object modified by the function, so const is ambiguous to the compiler.

Recall that const keeps objects constant, but there may or may not be an object here to keep constant.

Answer 4

When you apply the const qualifier to a nonstatic member function, it affects the this pointer. For a const-qualified member function of class C, the this pointer is of type C const*, whereas for a member function that is not const-qualified, the this pointer is of type C*.

A static member function does not have a this pointer (such a function is not called on a particular instance of a class), so const qualification of a static member function doesn't make any sense.