Prevent public uses of a class used as a private base class

Question

How can ensure that only "my" code can use a class, even if it is used a base class? (If it's not used as a base class I can make it a private or protected nested class of one of my classes)

If I want to indicate that use of a base class for one of my classes is a mere implementation detail, I can use a private base class:

 class Base
 {
      ...
 }

 class Derived: private Base
 {
 public:

      Derived(...): Base{...} {... };

      ...
 }

To clients of my Derived class, that I used the Base class is not apparent:

 #include "Derived.h"

 void client() {
    Derived d{...};
    Base *b = static_cast< Base * >(&d);// error
    ...
 }

But imagine that the Base class is so specialised, or confusing, or tricky to use, that I don't want it to be possible for clients of my code to use it as a base class or create objects of that class. I want it to be "private", in some sense, to some of my code, so client code like this fails:

 #include "Derived.h"

 class Client: Base// error wanted here
 {
 public:
    Client(...): Base{...} {...};

    ...
 }

 void client()
 {
    Derived d{...};// OK
    Base b{...};// error wanted here
    Client c{...};// error wanted here
 }

How can I do that?

In effect, I am asking how can I achieve something like Java's package-private classes, which are accessible to only other classes in the same "package" (module), but can not be used by code outside the "package".

Answer 1

You can "enforce" this by convention, by placing the "private" entities into a detail namespaces. Many popular libraries (e.g. Boost) do this:

namespace detail
{
    class Base { /* ... */ };
}

class Derived : private detail::Base
{
    /* ... */
};

---

When modules will be standardized this problem will be solved properly, as you will be able to control what entities get exported and which ones are implementation details.

Answer 2

This can't be done directly as you would do in Java. If it's only a matter of avoiding confusion you can move Base inside a namespace which is meant to be ignored by clients of your code, eg:

namespace hidden {
  class Base {
    ..
  };
}

class Derived : private hidden::Base {
  ...
};

If instead you really want to avoid the possibility of using Base then it's quite a difficult story if you plan to use Base as a parent of multiple classes (which amount could vary over time). You could give Base a private constructor, and indicate that each of your derived classes is a friend of Base:

class Hider {
  private:
    Hider() = delete;
    class Base {
      ..
    };

  friend class Derived;
};

class Derived : Hider::Base {
  ..
};

Of course this requires manual maintenance for each new class you want to derive from Base.

Answer 3

If you want to enforce it 100%, and don't like the python method of" please don't use things that start with '_'" then I believe this is your port of call:

class Dave;

class MyPrivateBaseClasses {
  private:
    MyPrivateBaseClasses();    // ensure nothing can use this class
    class BaseClassA {};

    friend Dave;
};

class Dave : public/private MyPrivateBaseClasses::BaseClassA
{};

Sure - it means you have to friend everything that wants to use it, but it does give you exactly what you wanted; 100% protection against people using BaseClassA.