Have you heard of or used "late binding"? Try it this way

#include <iostream.h>

class Shape { public: virtual ~Shape(){}; 
    public:
    virtual void ShowType()
    {
      cout << "Shape" << endl;
    }
};

class Polygon : public Shape { 
    public:
    virtual void ShowType()
    {
      cout << "Polygon" << endl;
    }
};

class Circle : public Shape { 
    public:
    virtual void ShowType()
    {
      cout << "Circle" << endl;
    }
};

int main() {
  Circle circle;
  Polygon polygon;
  
  Shape *shape1 = &circle;
  shape1->ShowType();
  
  Shape *shape2  = &polygon;
  shape2->ShowType();
  
}
[download]

Outputs:

c:\test>696596
Circle
Polygon
[download]

This is essentially the same as "re-blessing" a blessed-reference in Perl 5.

If I add a new method to my class, I have to remember to go add a check for that method to all places where it is loaded dynamically.

If you add a new method, you are going to have to modify any program that uses the class anyway, otherwise it will never be called. Reflection will tell you that it's there, but it won't tell how to call it, when to call it, what it will do, or why.

So, as you 've got to go in there and modify any program that uses the modified base class anyway, you might as well update the run-time sanity-checking code to test if the objects you are instantiating have been upgraded with that new method also.

And checking that it appears to do the right thing at run-time is just good insurance. Think of it as adding another test to your test suite. Except that it is one that protects your code by checking that other people (whomever writes the plug-ins derived from your plug-in base class), have done theirs.

Easier said than done if your code is a library being used by other programs who are creating the object in question and passing it in.

Okay. Your scenario is that you are providing a library that accepts instances of the errent class, that have been instantiated by code that you did not write.

So, you write your library in terms of the subclass of that errent class as I described above. Whenever your code gets an instance of that errent class, you use the late binding trick to "re-bless" it on the way in as as above. And then reverse the process (assignment) on the way out.