Const static member functions: is another approach available?

Question

As reported in this Q&A, const static member functions are/were not available in C++. Did anything change since then (2011)?

Is there another way to have static member functions that do not modify the static members of their class?

Something like (pseudo-code):

class C
{
   static int a;
public:
   static void Incr() { ++a; }
   static int  Ret() const { return a; }
};

int C::a = 0;

I would need to call a [const] static member function from another class' const member function.

You can move all the static data into a static instance of a class, and have a const member function of that class. — Brian Bi, Sep 16 '19 at 15:25
In generic cases, you cannot really check for constness of globals. Imagine `static void C::Foo() const { ::bar(); Ret(); }` and `void ::bar() {C::Incr();}`. — Jarod42, Sep 16 '19 at 15:34
All these problems go away if you stop using global state, like @Brian suggested. — Max Langhof, Sep 16 '19 at 15:55

score 8 · Answer 1 · answered Sep 16 '19 at 15:24

According to the current cppreference.com (page about static members), static member functions still cannot be const, because the const keyword only modifies the this pointer, which static functions obviously do not have.

So nothing seems to have changed since the answer you were referring to was written.

StoryTeller - Unslander Monica · Answer 2 · 2019-09-16T16:11:16.213

4

Did anything change since then (2011)?

Nothing changed, you still can't cv-qualify a static member function.

Is there another way to have static member functions that do not modify the static members of their class?

Not a perfect solution, but you may declare const "aliases" to static data members:

static int  Ret() { 
    static constexpr const auto& a = C::a;
    // Now C::a is shadowed by the local a
    // and the function can't modify it.
    // a = 2; // ill-formed
    return a * 2; // OK
}

It still requires discipline, but at least that way a compiler can catch unintended modification attempts.

edited Sep 16 '19 at 16:11

answered Sep 16 '19 at 15:27

StoryTeller - Unslander Monica

165,132
21
377
458

I like that this enables compile errors, but I don't like that this behavior is not (/ does not have to be) reflected by the function signature – eike Sep 16 '19 at 15:31
2

@eike - I hear ye. I also get where the OP is coming from. But this is the closest approximation I could think of. – StoryTeller - Unslander Monica Sep 16 '19 at 15:32
Not really scalable though, should be done for each static members, for all static const methods :-/ – Jarod42 Sep 16 '19 at 15:43
Call non-static-methods (which can so be `const`) from singleton is an alternative for that approximation, but indeed need to change call sites. – Jarod42 Sep 16 '19 at 15:44
@Jarod42 - For each member the method *uses*, that's the discipline part. And I'll re-iterate, this is far from perfect. – StoryTeller - Unslander Monica Sep 16 '19 at 15:44
From Visual C++ 2013, I get the error: C2272 - 'get' : modifiers not allowed on static member functions – Pietro Sep 16 '19 at 15:47
1

@Pietro - What `get`? I can't tell you what you did wrong on code I cannot see. – StoryTeller - Unslander Monica Sep 16 '19 at 15:49
@StoryTeller: sorry, I ment `Ret()`. – Pietro Sep 16 '19 at 16:10
1

@pietro - I see now. I made a copy paste error. Removed the erroneous bit now. Don't const qualify the method itself. That's plain illegal. – StoryTeller - Unslander Monica Sep 16 '19 at 16:12

score 3 · Answer 3 · answered Sep 16 '19 at 15:56

Class which has only static fields and static methods doesn't deserve to be called class. It is just form of functions and global variables with fancy name spacing.

Anyway IMO it is much better to have a regular class with regular fields and methods and then instantiate it as a global variable (not very nice solution, but at least more honest where class contains only static fields and methods).

class C
{
   int a;
public:
   C() : a(0) {}
   void Incr() { ++a; }
   int  Ret() const { return a; }
};

C instance;

Or use singleton pattern which I hate.

From generated code perspective there should be no difference.

Const static member functions: is another approach available?

3 Answers3