Convert const T* const to T* - c++

Question

is it possibile do this kind of cast in C++?
I need to declare my attribute in this way.
Class A {
public:
void update() { ++i_; }
private:
int i_;
}
Class B{
public:
void foo() {
a_->update(); /* Error */
}
private:
const A* const a_;
}
Error is:
passing ‘const A’ as ‘this’ argument of ‘void A::update()’ discards
qualifiers [-fpermissive]
I try with static_cast, but is not enough.. does not work.. any ideas?

Answer 1

You have two choices here. Either make A::update a const function-
Class A {
void update() const;
}
or remove the constness of the pointer.
Class B{
public:
void foo() {
const_cast<A*>(a_)->update();
}
private:
const A* const a_;
}
The former would be the preferred method, but that will also stop you from doing anything useful in class A's update.
As a rule of thumb, if you have to cast the const off something then you really want to look at why the pointer is const in the first place.

Answer 2

Using a const member with a non-const method is forbiden (unless using mutable). Put a const after declaration of foo() and update():
void update() const { ... }
^^^^^
void foo() const { ... }
^^^^^
or ...
If you don't want to make update a const, you can use const_cast:
void foo() const // Now, this const keyword is optional but recommanded
{
const_cast<A*>(a_)->update();
^^^^^^^^^^^^^^
}

Answer 3

You've got a few options:
use const_cast to cast away the const and call the method.
make update a const method, so that it can be called through a const pointer.
don't store a_ as const in the first place. Change it to A* const a_ so that you can call non-const methods, but the pointer cannot be changed.

Answer 4

Assuming that you cannot declare the method as const and that you know what you are doing (tm) and why this is bad: Try the const_cast!

Answer 5

The const after * has nothing to do with it. You must declare your functions which use a_ as const functions. If they don't compile, you must use const_cast or reinterpret_cast to remove const from the pointer before calling.. But this is very dodgy, and if update() function modifies an object which was originally declared const, this is undefined behaviour.

Answer 6

The error you get
passing ‘const A’ as ‘this’ argument of ‘void A::update()’ discards
qualifiers [-fpermissive]
is result of calling non-const method on a const pointer. This is forbidden. Since you require an update to be non-const and you cannot store a pointer to non_const A, you can use operator const_cast to cast away const and here is how to do it:
class A {
public:
void update(){}
};
class B{
public:
void foo() {
const_cast< A*>(a_)->update(); /* OK*/
}
private:
const A* const a_;
};
You should however rethink your design.

Answer 7

As mentioned by someone before, use mutable/const but this changes your design a little bit:
class A {
public:
void update() const { ++i_; } // this will make the method callable by const A*
private:
mutable int i_; // and this will make you field mutable in a const method
};
class B{
public:
void foo() {
a_->update();
}
private:
const A* const a_;
};