Q:

a const member function, returning a pointer to a non const member variable, why would it be good?

I work in a large collaboration (of mostly non-professional programmers, I being one of them). I regularly see examples of the following
void T::DoChanges(I i); // will make changes to internal structure of T (non-const)
V T::GetValue();

class A
{
private:
  T* fMember;
public:
  A(); 
  T* GetMember() const {return fMember;}
}

, Where a use-case would be
A a;
I i;
a->GetMember()->DoChanges(i);
V v = a->GetMember()->GetValue();

This practice violates a tenant drilled into me when i took programming courses, i.e. that const refers not only to the bitwise structure of the class instance, but the internal logical structure. 
Under this philosophy, the member function should take the following forms:
T* GetMember() {return fMember;}
const T* GetMember() const {return fMember;}

I have heard that some people think that const should only refer to members, speaking strictly using the c++ terminology. How/why would someone argue for this type of practice?

A:

Making the member function gives the indication to the users of this function that it will not modify any class members.
The returned member may or maynot be const but making the member function const gives the users of the class a clear indication of the behavior of function.

