Should I totally hide the internal class in my C++ header file when designing my SDK?

Question

I am designing a SDK written in C++. I have a question: could or should I totally hide the internal class in my public C++ header file?

The code snippets are like the following (in the header file MyPublicClass.h):

namespace PublicNamespace
{
   namespace InternalNamespace
   {
      class MyInternalClass;
   }

   class MyPublicClass
   {
      public:
         void SomeMemberFunc();
         ...

      private:
         std::shared_ptr<InternalNamespace::MyInternalClass> mImpl;
   }
}

Per the C++ PImpl design pattern (and also many other materials from Google), it is OK to put the InternalNamespace::MyInternalClass into the public header.

My thought is: it looks unnecessary to let the external users know the internal namespace InternalNamespace, and also the class MyInternalClass. So I want to use void to replace the type InternalNamespace::MyInternalClass.

That's to say, for my case, I use std::shared_ptr<void> as the type of the data member mImpl, and in the .cpp file, use std::static_pointer_cast<InternalNamespace::MyInternalClass>(mImpl) to convert it to the actual class. (Yeah, I know there is a little cost with this conversion but please ignore it).

Is this design correct or proper? Thanks all.

Answer 1

Don't use void or void * unless there is absolutely no alternative -- using void-pointers prevents the compiler from catching mistakes at compile-time, and leads to pain and suffering.

Using a clearly-labelled InternalNamespace should be good enough (assuming the programmers using your API aren't deliberately looking for trouble -- and if they are, there are plenty of other ways for them to find it anyway), although if you wanted to hide MyInternalClass entirely from calling code, you could instead make it an inner-class of MyPublicClass, i.e. something like this:

namespace PublicNamespace
{
   class MyPublicClass
   {
      public:
         void SomeMemberFunc();
         ...

      private:
         class MyInternalClass 
         {
            [...]
         };

         std::shared_ptr<MyInternalClass> mImpl;
    }
}

Since it's declared in the private section of MyPublicClass, no calling code outside of MyPublicClass would be able to access it at all.