In C++, is a const method returning a pointer to a non-const object considered bad practice? For example. consider the following methods:
// Makes perfect sense
bool isActive() const { return m_isActive; }
// Makes perfect sense, both consts ensure nothing is modified
const SomeObject* someObject() const { return m_someObject; }
// Makes perfect sense, no const because SomeObject is mutable,
// thus MyClass is indirectly mutable
SomeObject* someObject() { return m_someObject; }
// Makes no sense, if you're just returning a pointer to a const object,
// then the method should clearly be const since nothing can be modified
const SomeObject* someObject() { return m_someObject; }
The last combination puzzles me: is the following considered bad practice?
SomeObject* someObject() const { return m_someObject; }
Because the class that method returns is not const, but the method is, it is somewhat pointless since you could modify SomeObject and thus indirectly modify your class... so is that form considered bad practice? e.g. should you only use one of the following in place of it?
const SomeObject* someObject() const { return m_someObject; }
SomeObject* someObject() { return m_someObject; }
Real-world situation: I'm writing a smartphone game which has a Game class. The Game class contains several methods which return pointers to utility classes like InputManager, AudioManager, etc.
class Game
{
public:
InputManager* inputManager() const { return m_inputManager; }
...
private:
InputManager* m_inputManager;
...
}
Does it make ANY sense at all to make inputManager() const, since the object it returns is not? (and should not be, since the InputManager needs to be mutable for its state to be updated, etc.)
Or should I remove the method's const modifier to more accurately reflect the method's behavior? That way if I had a const Game, I couldn't call inputManager() and then mess with the Game's input manager even though the Game was const.