Call specific method on static const member - c++

Question

Here is the idea: I have a class that has some member variable(s), say x. This class also has a method, A(), which does not modify the member variable(s), but returns info about them. There is also a method B() which does modify the member variable(s). So basically, this is the setup:
class Class
{
int x;
Class(int x) : x(x) { }
int A() { return x; /* info about x */ }
void B() { x++; /* updates x! */ }
}
So far so good. But now I want to have some special version of this class that will be used throughout the project, and I want it to have a specific set of member variable(s), say, x = 3. My idea was to add a const static Class mySpecialCase member to Class, and just refer to Class::mySpecialCase whenever necessary.
The problem however, is that I need to call A() on this object, to fetch some information, but do not want B() to be called on this object, since it would modify x, which would affect all future usage of the 'special case'.
Any ideas on how to solve this?

Answer 1

It's already illegal to call Class::mySpecialCase.B(), since mySpecialCase is const and B() is not a const member. You just need to make it possible to call A(), by making A() a const member function:
class Class
{
int x;
public:
Class(int x) : x(x) { }
static const Class mySpecialCase;
int A() const { return x; /* info about x */ }
void B() { x++; /* updates x! */ }
};
// In class.cpp:
const Class Class::mySpecialCase{3};

Answer 2

The problem however, is that I need to call A() on this object, to fetch some information, but do not want B() to be called on this object, since it would modify x,
Declare the object and B() as const but not A():
class Class {
public:
[...]
int A();
void B() const;
};
// Initialize const object.
const Class specialCase(3);
Calling specialCase.A() will be a compile error, but specialCase.B() is still okay because the const modifier indicates to the compiler this method does not alter the object.

Answer 3

So far so good.
Not really. A should be const:
int A() const { return x; /* info about x */ }
But now I want to have some special version of this class
By version, you mean instance, right?
Add a static member function returning a reference to a static local instance of Class:
#include <iostream>
class Class
{
public:
int x;
Class(int x) : x(x) { }
int A() const { return x; /* info about x */ }
void B() { x++; /* updates x! */ }
static Class &SpecialInstance()
{
static Class instance(3);
return instance;
}
};
int main()
{
Class a(1);
Class b(2);
Class c = Class::SpecialInstance();
std::cout << c.A() << "\n";
}