Use some methods of a class in subclass without inheritance in c plus plus?

Answer 1

You can't have a subclass without inheritance. A subclass is just another name for a derived class, and derived classes inherit all the public and protected members of their base classes. You cannot have a base class with neither public nor protected members -- there has to be at least one exposed interface, even if it is only a static public method.

I suspect you are actually asking how to call a specific method of a derived class when all you have is a pointer to its base class. The correct solution is to use inheritance and call a virtual method of the base class. But what do you do when the specific method you want to call is non-generic?

This is a classic case of poor class design. The problem is not that you are trying to extort non-generic behaviour from a base class, the problem is in how you are going about it. If you only have a pointer or reference to the base class then you are expected to make use of its generic interface. If you need a more specific interface, then you need a pointer or reference to the more specific type, not its generic type. Unfortunately, this may not always be possible, especially when dealing with legacy code for which you have no control over. In these cases, the only solution is to resort to expensive runtime type information and dynamically cast your base class pointer to the appropriate type. If the return value is NULL then the base class does not point at your expected derivative, so you must check the return value is non-NULL before calling the specific method. This is the only safe way of doing it, in the absence of a suitable generic interface.

This, in turn, means your calling code requires knowledge of that specific type. While that's generally not a problem when the calling code is external to the base class, it is a problem when the calling code is the base class itself. This means your base class must be blessed with knowledge about some or all of its derivatives. To be blunt, that's a maintenance nightmare because every time you derive a new object for which you wish to extort specific behaviour you must also update the base class in order to accommodate that new derivative. Quite simply this is a sloppy way of going about things.

The best solution is, of course, to rethink your design. Separate your interfaces from your implementations and gather all the common interfaces together in the base class itself. Look into ways of generalising the more specific methods such that it is possible to call those methods from the generic interface, without the need for runtime type information. Use arguments as flags to allow greater flexibility, and let the more specific implementations work out for themselves exactly which calls to make based upon those arguments. You cannot avoid using inheritance, of course, but ultimately it is the correct way of doing things. Your code will be cleaner and easier to maintain in the long run. And it all starts with good design.