// api.h

// c-style api

struct handle;

handle* create_foo();
handle* create_bar();

long foo_fun(handle*);
long bar_fun(handle*);

// api.cpp
#include "api.h"

struct handle
{
     virtual ~handle() {}
};

struct foo : handle
{
     long fun();
};

struct bar : handle
{
     long fun();
};

handle* create_foo()
{
     return new (nothrow) foo;
}

long foo_fun(handle* h)
{
     if(foo* p = dynamic_cast<foo*>(h))
         return p->fun();
     else
         return E_BAD_HANDLE;
}

ME>// api.h

ME>// c-style api

ME>struct handle;

ME>handle* create_foo();
ME>handle* create_bar();

ME>long foo_fun(handle*);
ME>long bar_fun(handle*);
ME>

ME>// api.cpp
ME>#include "api.h"

ME>struct handle
ME>{
ME>     virtual ~handle() {}
ME>};

ME>struct foo : handle
ME>{
ME>     long fun();
ME>};

ME>struct bar : handle
ME>{
ME>     long fun();
ME>};

ME>handle* create_foo()
ME>{
ME>     return new (nothrow) foo;
ME>}

ME>long foo_fun(handle* h)
ME>{
ME>     if(foo* p = dynamic_cast<foo*>(h))
ME>         return p->fun();
ME>     else
ME>         return E_BAD_HANDLE;
ME>}
ME>

#include <iostream>
#include <windows.h>

class CTestClassBase
{
public:
    CTestClassBase(){};
    virtual ~CTestClassBase(){};
    virtual void Test(int Member) = 0;
};

class CTestClass : 
    public CTestClassBase
{
public:
    CTestClass(){};
    ~CTestClass(){};
    void Test(int Member){m_Member = Member;};
private:
    int m_Member;
};

void Test()
{
    CTestClassBase * ptb1;
    CTestClassBase * ptb2;
    {
        CTestClass t;
        ptb1 = &t;
        // ptb1 = new CTestClass(); // Можно и так

        ptb2 = dynamic_cast<CTestClassBase *>(ptb1);
        ptb2->Test(100);

        // delete ptb1; // Можно и так
    }
    ptb2 = dynamic_cast<CTestClassBase *>(ptb1); // Вроде бы все хорошо
    ptb2->Test(200); // Упс, приехали :(

};

void main(void)
{
    Test();
}