Why there is no concept of "const-correctness" for class's static member functions?

Question

Use case:

class A {
  static int s_common;
public:
  static int getCommon () const { s_common; };
};

Typically this results in an error as:

error: static member function ‘static int A::getCommon()’ cannot have cv-qualifier

This is because constness applies only to the object pointed by this, which is not present in a static member function.

However had it been allowed, the static member function's "const"ness could have been easily related to the static data members.
Why is this feature is not present in C++; any logical reason behind it ?

@keety, [that question](http://stackoverflow.com/questions/7035356/c-why-static-member-function-cant-be-created-with-const-qualifier) is related and not duplicate, I had seen that and upvoted it. The `this` pointer argument I have mentioned in my question also and it doesn't seem to be sufficient. — iammilind, Apr 11 '12 at 06:07
cool but maybe better if you link the original thread in the question to get a context or you mind end up with the same answers — keety, Apr 11 '12 at 06:09

score 8 · Accepted Answer · answered Apr 11 '12 at 06:07

8

cv-qualifiers affect the function's signature. So you could have:

class A {
  static int s_common;
public:
  static void getCommon () const {  };
  static void getCommon () {  };
};

Now... how would you call the const one? There's no const object to call it on (well, you could call it on a const object, but that's not the point).

I'm just guessing here, there probably are other reasons. :)

answered Apr 11 '12 at 06:07

Luchian Grigore

253,575
64
457
625

3

Such a combination could simply be considered illegal. I'm not sure its a good enough reason to rule out the possibility. – Michael Anderson Apr 11 '12 at 06:10
2

@MichaelAnderson why would it be illegal? The standard says you can overload by cv-qualifiers. Anything can be deemed illegal if we alter the rules enough. – Luchian Grigore Apr 11 '12 at 06:12
-1 @Luchian: the new rules that would allow `static const` would have to make the overloading invalid, since it cannot easily be resolved except by casting. that's the why of it. so i think your answer was incorrectly selected as a solution: it is not a reason at all, just an associative misconception. – Cheers and hth. - Alf Apr 23 '12 at 09:49
@Cheersandhth.-Alf of course you could modify the rules to make anything invalid. But this was just a guess (as noted in the answer itself). I don't think it's an invalid answer just because you can think of a way the rules can change to invalidate it. – Luchian Grigore Apr 23 '12 at 09:52
Very good point, but as you suspected yourself, the actual reason is different. It is given in the answers by Nicol Bolas and Alok Save. – Frank Puffer Jan 27 '18 at 09:47

score 8 · Answer 2 · answered Apr 11 '12 at 06:14

However had it been allowed, the static member function's "const"ness could have been easily related to the static data members.

This is where your question becomes confused. A non-static member function declared as const still has non-const access to static data members. The const only applies to this (ie: the non-static data members).

It would make no sense for a static member function to use const in the same way syntactically, yet have a completely different outcome (ie: making access to static data members const).

Furthermore, static data members are nothing more than class-scoped global variables that have class access controls (public/private/etc) on them. So it doesn't make sense for some functions to have different const access to them, especially based on their signature.

score 5 · Answer 3 · answered Apr 11 '12 at 06:06

5

The rationale for having const cv-qualifier on member functions is:
To indicate that the hidden pointer this being passed to the member function is immutable and it cannot be modified. A static member function does not have the hidden this parameter, and hence const for static member functions is meaningless.

However had it been allowed, the static member function's "const"ness could have been easily related to the static data members.

That was not the rationale for having const qualifier to begin with, this is evident from the fact that you cannot have cv-qualifiers applied to a free function. The cv-qualifiers were and are only meant for this, the object whose function is being called.

answered Apr 11 '12 at 06:06

Alok Save

202,538
53
430
533

I have also deleted my comment since it has no meaning without your previous comment. I feel an infinite loop coming on. :)) – Luchian Grigore Apr 11 '12 at 06:35
Interesting, I had simply been thinking of the `const` as a way of stating the function wouldn't change the object. That means it's superfluous for a static function (since it *has* no object) but I can't see why it would be *disallowed* rather than just ignored. – paxdiablo Feb 02 '18 at 05:52

score 2 · Answer 4 · answered Apr 11 '12 at 06:19

2

A function that doesn't change any global state is pure. C++11 introduces attributes that might include [[pure]] on particular platforms.

One problem with const is that it's part of the type of the function. Assigning that static const function to a "normal" function pointer would require a special conversion, cast, or decay rule. And as Luchian mentions, it would allow completely ambiguous overloading.

Essentially you are describing forming a singleton object from the static members, sharing a common, qualified indirect access path. For the non-const object to appear const, it must be accessed through something, but there's no this. Would its decltype change? There is no good answer. If you want all this, then put them explicitly inside a class object.

answered Apr 11 '12 at 06:19

Potatoswatter

134,909
25
265
421

That's a good point. Is [[pure]] an extension ? I generally refer to [wiki link for C++11](http://en.wikipedia.org/wiki/C%2B%2B11), but couldn't find that by simple grep. – iammilind Apr 11 '12 at 06:22
@iammilind `[[pure]]` is not standard, and I don't suppose any platform implements it. But GCC has `__attribute__((pure))` and MSVC has something similar, IIRC. Attributes are controversial and there may be a boycott among major implementations (see Herb Sutter's recent article) so things like `[[pure]]` might never be portable. – Potatoswatter Apr 11 '12 at 06:26

score 1 · Answer 5 · answered Apr 11 '12 at 06:05

1

My guess is that using static and const on a member function to refer to constness of static member variables was simply never considered as an option. IMO your suggestion is kind of a strange (but maybe sensible) way of mixing those two keywords.

answered Apr 11 '12 at 06:05

Michael Anderson

70,661
7
134
187

score 1 · Answer 6 · answered Apr 11 '12 at 06:09

Good question.

I believe conceptually const-ness applies to well-defined object or a data structure. Not to global/static or etc.

The same way I may ask why a global (or alternatively namespace-specific) function may not be const, i.e. it may promise not to modify any global (or namespace-specific) variables.

This doesn't make too much sense IMHO. But yes, const-ness of static members belonging to a specific class - this might be useful in some cases IMHO.

Why there is no concept of "const-correctness" for class's static member functions?

6 Answers6

Linked