A method which can only be invoked when referring to base class? C++

Question

Say I have an abstract class

class NecessaryDanger
{
public:
     virtual void doSomethingDangerous() =0;
}

and a class that is derived from this class:

class DoesOtherStuff : public NecessaryDanger
{
     //stuff
     void otherMethod();
     void doSomethingDangerous();
}

is there a way I can only allow access of doSomethingDangerous() like

DoesOtherStuff d;
d = DoesOtherStuff();
d.otherMethod(); //OK
d.doSomethingDangerous(); //error

NecessaryDanger* n = &d;
n->doSomethingDangerous(); //OK

I am not very good at C++ yet, so the code above may not be quite right, but you maybe get the idea. I have a set of classes that need to have the ability to do "something dangerous" (in their own special way) that could cause problems if more than one object of these classes does this dangerous thing. I would like to have a manager class that has a NecessaryDanger pointer to only one object. If the method doSomethingDangerous could only be called by a NecessaryDanger object, then it would be more difficult for an accidental call to doSomethingDangerous to happen and cause me headaches down the road.

Thanks in advance for the help. Sorry in advance if this is a dumb question!

Answer 1

Sure. Just make it private in the derived class and public in the base.

Of course, if NecessaryDanger is a public base, then anyone can cast and call. You might want to make it a private base and use friend.

class DoesOtherStuff : private NecessaryDanger
{
     //stuff
     void otherMethod();

private:
     void doSomethingDangerous();

     friend class DangerManager;
}

Answer 2

Remove the virtual classifier in the superclass so that the compiler does compile-time binding based on the variable type instead of run-time binding based on the object type.

Answer 3

Building on Potatswatter's response :)

Here is Herb's advice: (especially 1 and 2) applicable in this context.

Guideline #1: Prefer to make interfaces nonvirtual, using Template Method.
Guideline #2: Prefer to make virtual functions private.
Guideline #3: Only if derived classes need to invoke the base implementation of a virtual function, make the virtual function protected.

For the special case of the destructor only:

Guideline #4: A base class destructor should be either public and virtual, or protected and nonvirtual.