Const references sometimes lead to confusion - c++

Question

I'm new to C++. I learned that references should be used whenever possible and that pointers should be used only when strictly necessary. I also learned that const references should be used in function parameters when the function does not change the referred variable.
I understand the reasons and agree with them, but there's a common case where const references lead to confusion which is when a mutable object "becomes immutable" as an effect (const-ness) of declaring a const reference to an object. For example, the Foo class has a method named incrementX() which mutate the state of Foo when called:
class Foo {
public:
void incrementX();
private:
private int x;
}
void Foo::incrementX() {
x++;
}
class Bar {
public:
void doSomethingWith(const Foo &foo);
}
void Bar::doSomethingWith(const Foo &foo) {
foo.incrementX(); // <- illegal because incrementX() is not a const method
}
int main() {
Foo foo;
Bar bar;
bar.doSomethingWith(foo);
}
The usual solution is to declare incrementX() as a const method, which in turn forces me to declare the variable x as a mutable variable. The problem is, by turning incrementX() into a const method I'm saying that this method is not supposed to mutate the object's state, which is not true in the above example. Not only it's not true, it's also the method's intent to mutate the object's state.
I'm curious how experienced C++ programmers deal with this situation. I'm inclined to use const pointers (Foo * const foo) in such cases, would that be recommended/discourage?
Thanks.
EDIT: Just to clarify the cause of my confusion, I often hear people saying "use const refs when the function promises not to change the parameter", but what exactly "to change the parameter" means? Does it mean the function promises not to assign a new object to the parameter, or does it mean it will not mutate the objects's state? Of course, const references disallow both kind of changes, but what's the main concern when it comes to const references? Is it that it will not assign a new value to the parameter, or is it that it will not mutate the state of the object referred to by the const reference?

Answer 1

By taking const Foo &
void Bar::doSomethingWith(const Foo &foo)
promises not to modify the foo. Therefore it may not call it's non-const incrementX method.
If you have Bar::doSomethingWith(Foo &foo) that needs to call foo.incrementX (and therefore needs to take it's argument non-const reference), than you should reconsider whether it is really appropriate to be a method of Bar and not Foo in the first place.

Answer 2

Do not pass by const reference if you expect that your object will be changed, or overload the function so that you have doSomethingWith(const Foo&) and doSomethingWith(Foo&).
The whole idea is that passing by const reference forces const behaviour, so you can only invoke member functions that are marked const, and this leads to less problems in the long run.
PS: I made the doSomething a member of Foo.
Example:
#include <iostream>
using namespace std;
class Foo
{
int m=0;
public:
void doSomething(const Foo& foo) const
{
cout << "calling const reference" << endl;
}
void doSomething(Foo& foo)
{
cout << "calling reference" << endl;
foo.m++;
}
};
int main()
{
const Foo f,g ;
f.doSomething(g); // calls const reference
Foo h,k;
h.doSomething(k); // calls reference
}