Why am I being told "this method could be const"?

In a class

class Foo
{
public:
    void DoSomething(int x) const;

private:
    int m_bar;
};

one is not allowed to write

void Foo::DoSomething(int x) const
{
    m_bar = x; // Error
}

I have to remove the const modifier, However, if I have

struct Data
{
    bar;
};

class Foo
{
public:
    void DoSomething(int x) const;
private:
    Data * m_data;
};

void Foo::DoSomething(int x) const
{
    m_data->bar = x;
}

then that's not only fine,but I get warned "method can be const" by code validation tools if I remove the modifier?

I shouldn't be able to modify the state of an object in a const method, irrespective of how that state is represented!

The const qualifier tells the compiler that the function will not modify any member variables of the object. So if you have a pointer member variable, a const function will not be able to change the pointer itself.

But that only goes for the actual member variable. The data that the pointer is actually pointing to is not constant. For that you need a pointer to a constant object (e.g. Data const* m_data;).

Pointers point somewhere. If you modify a pointer you modify where it points to.

Because pointers point somewhere you can dereference them to access the pointee. Modifying the pointee does not modify the pointer.

For the sake of illustration, imagine you had no pointer but instead an index into an array:

struct Data
{
    int x;
};

Data my_memory[42];

class Foo
{
public:
    void DoSomething(int x) const;
private:
    size_t m_index;  // "points to" a Data element in my_memory
};

void Foo::DoSomething(int x) const
{
    my_memory[m_index].x = x;
}

Of course pointers are not indices into arrays. Though as mental image it is more accurate than you might expect. The index refers to the actual object which is stored elsewhere. You can modify the index which has no effect on the object. You can use the index to access the object and modify it without modifying the index. Thats just the same as your pointer does.

I hope now it is obvious that Foo::DoSomething should be const. You are modifiying the Data object, which is not part of Foo. Foo only contains a pointer to the object. DoSomething does not modify that pointer.

The object is taking some X memory at some address P.
A member function of with the const qualifier, can't change DIRECTLY the memory X at at this address, this is why a function can be mark as const

In the case below, we CAN change the memory of the object inside a const object

struct A {
    public:
    A(): x(5) { x_p =&x;};
    void update_x()  const { *x_p = 3;}
    
     int x;
     int *x_p;

};

Compile and run :

int main()
{   
    A a;
    std::cout << a.x << std::endl;
    a.update_x();
    std::cout << a.x << std::endl;
}

would get:

3
5