C++ : Add a method to a base class interface - c++

Question

Suppose I have a third-party library with a large polymorphic class hierarchy:
Base => Sub1, Sub2, Sub3 => SubSub1, SubSub2 ... etc.
I can take a bunch of objects from various subclasses within the hierarchy, stuff pointers of type *Base into a STL container, then use an iterator to call a specific base class method on each.
What if I want to add a new virtual method to the base class then do the same thing, calling that method for each object in the container?
The base class is part of a library, so I can't just add a new virtual method to it. Deriving a subclass does not work because I lose access to all of the other subclasses. In Java, I would create an interface and have each of the relevant subclasses implement it. I am not sure how best to handle this problem in C++, though.
EDIT:
(1) The visitor pattern suggested below would be a great solution, but requires that the original base class be written with that pattern in mind.
(2) The plug-in pattern suggested below is a generalized solution that works, but can be very slow in certain use-cases.
(3) Deriving a subclass from Base, then refactoring the whole hierarchy so that it derives from this subclass is cumbersome and might break if the library code is upgraded.
(4) I try to avoid multiple inheritance, but it works in my (simple) use-case:
#include <third_party_lib.h>
class MyBase {
public:
virtual ~MyBase() {}
virtual void myMethod() = 0;
};
class MySub1 : public ThirdPartyLib::Sub1, MyBase {
public:
void myMethod() { /*...*/ }
};
class MySub2 : public ThirdPartyLib::Sub2, MyBase {
public:
void myMethod() { /*...*/ }
};
void doSomething() {
std::vector<ThirdPartyLib::Base*> vec;
// fill vector with instances of MySub1, MySub2, etc
for (auto libHandle : vec) {
// call a method from the library class hierarchy ...
libHandle->libraryClassMethod();
// call the virtual method declared in MyBase ...
MyBase* myHandle = dynamic_cast<MyBase*>(libHandle);
if (myHandle) {
myHandle->myMethod();
} else {
// deal with error
}
}
}

Answer 1

If you don't have the option of modifying the base class, you can use a pattern that I call the plugin pattern.
You create a global function or a function in an appropriate namespace to perform operations given an object of type Base.
You provide a mechanism where the implementation for a derived type can register itself.
In the implementation of the function, you iterate over the registered functions/functors to check whether there is an implementation for the type of the object. If yes, you perform the operation. Otherwise, you report an error.
Let's say you have:
struct Shape
{
// Shape details
};
struct Triangle : public Shape
{
// Triangle details
};
struct Rectangle : public Shape
{
// Rectangle details
};
For the purpose of illustration, let's say that Shape does not have an interface to compute the area of Shape objects. To implement the ability to compute the area of a shape, you can do this:
Create a function to get area of a Shape.
extern double getArea(Shape const& shape);
Add a registration mechanism for functions that can compute area of Shapes.
typedef double (*GetAreaFunction)(Shape const& shape, bool& isSuccess);
extern void registerGetAreaFunction(GetAreaFunction fun);
Implement the core functions in a .cc file.
static std::set<GetAreaFunction>& getRegistry()
{
static std::set<GetAreaFunction> registry;
return registry;
}
void registerGetAreaFunction(GetAreaFunction fun)
{
getRegistry().insert(fun);
}
double getArea(Shape const& shape)
{
double area = 0.0;
for ( auto fun: getRegistry() )
{
bool isSuccess = false;
area = fun(shape, isSuccess);
if ( isSuccess )
{
return area;
}
}
// There is no function to compute the area of the given shape.
// Throw an exception or devise another mechanism to deal with it.
}
Add functions to compute the area of Triangle and Rectangle, wherever it seems appropriate in your code base.
double getArea(Triangle const& triangle)
{
// Do the needful and return the area.
}
double getArea(Rectangle const& rectangle)
{
// Do the needful and return the area.
}
Add a function that can be registered with the core API.
double getAreaWrapper(Shape const& shape, bool& isSuccess)
{
// Do dynamic_cast to see if we can deal with the shape.
// Try Triangle first.
Triangle const* trianglePtr = dynamic_cast<Triangle const*>(&shape);
if ( trianglePtr )
{
isSuccess = true;
return getArea(*trianglePtr);
}
// Try Rectangle next.
Rectangle const* rectanglePtr = dynamic_cast<Rectangle const*>(&shape);
if ( rectanglePtr )
{
isSuccess = true;
return getArea(*rectanglePtr );
}
// Don't know how to deal with the given shape.
isSuccess = false;
return 0.0;
}
Register the function with the core.
registerGetAreaFunction(getAreaWrapper);
Pros
This is an elaborate method for avoiding a long if-else block in one function.
It avoids hard dependencies in the core to deal with derived types.
Cons
Most important - don't use this for any function that needs to get called millions of times. That will kill performance.

Answer 2

There are actually two ways to accomplish this.
1) Add a class ( say base1 ) for which base would be your "base" class in library. Then let all other classes to derive from base1 rather than base.
2) Use multiple inheritance. You add another class "base1" , and then let other derived classes inherit both from "base" as well as "base1".
I would prefer former approach as multiple inheritance has it's own bottlenecks.