Abstract class - hiding implementation in C++ practice
c++, oop
Solution
You always have to hide as much as possible. Your way (putting implementation classes into .cpp) is a common way to do this in c++.
Problem
Recently I've been writing code similar to this: messagehandler.h: ``` #include "message.h" class MessageHandler { public: virtual ~MessageHandler() {} virtual void HandleMessage(Message *msg) = 0: }; ``` persistmessagehandler.h: ``` MessageHandler *CreatePersistMessageHandler(); ``` persistmessagehandler.cpp: ``` #include "messagehandler.h" #include "persist.h" class PersistMessageHandler : public MessageHandler { private: PersistHandle ph; size_t count; InternalCheck(); public: PersistMessageHandler(int someParam); virtual ~PersistMessageHandler (); virtual void HandleMessage(Message *msg): }; PersistMessageHandler::PersistMessageHandler(int someParam) { ph.Initialize(); } ... rest of implementation. MessageHandler *CreatePersistMessageHandler(int someParam) { return new PersistMessageHandler(someParam); } ``` The reasoning here is to hide the PersistMessageHandler. Clients don't need to include a header for the PersistMessageHandler class, with all the includes and types the implementation might need, and to more cleanly seperate the interface and implementation. . It'll always be dynamically allocated anyway, All PersistMessageHandler users will just call CreatePersistMessageHandler(..); directly or indirectly get one from a factory. But. I've not seen this approach used much elsewhere. Is the above good practice ? Are there other/better alternatives for simple cases ?