//Interface.h:
class IExportedObject
{
public:
    virtual void Release() = 0;
};

class IBusinessLogicObject : public IExportedObject
{
public:
    virtual void Foo() = 0;
};


//BusinessLogic.*:
class MyObject : public IBusinessLogicObject 
{
public:
    virtual ~MyObject()
    {
        printf("~MyObject\n");
    }
    virtual void Foo()
    {
        printf("Foo\n");
    }
};

//ExportIntafaces.*:
template <class T>
class ExportSingle : public T
{
public:
    virtual ~ExportSingle()
    {
        printf("~ExportSingle\n");
    }

    virtual void Release()
    {
        delete this;
    }
};

template <class T>
class ExportArray : public T
{
public:
    virtual ~ExportArray()
    {
        printf("~ExportSingle\n");
    }
    virtual void Release()
    {
        delete[] this;
    }
};


extern __declspec(dllexport) IBusinessLogicObject *CreateObject()
{
    return new ExportSingle<MyObject>;
}

extern __declspec(dllexport) IBusinessLogicObject *CreateObjects(int n)
{
    return new ExportArray<MyObject>[n];
}


//application
int main(int argc, char * argv[])
{
    IBusinessLogicObject *object = CreateObject();
    object->Release();
    
    IBusinessLogicObject *objects = CreateObjects(10);
    objects->Release();
    
    return 0;
}

M>static void* operator new (size_t s)
M>{
M>    printf("new from native module\n");
M>    return malloc(s);
M>}

M>static void operator delete (void* p)
M>{
M>    printf("delete from native module\n");
M>    return free(p);
M>}
M>

struct CSafeDeletableBase {
    virtual ~CSafeDeletable() {}
    
    void* operator new( size_t size ) { return ::operator new( size ); }
    void operator delete( void* block ) { ::operator delete( block ); }

    // Дальнейшие шаблоны по желниаю....
    template<typename T1>
        void* operator new( size_t size, T1 a1 ) 
            { return ::operator new( size, a1 ); }
    template<typename T1>
        void operator delete( void* block, T1 a1 ) 
            { return ::operator delete( block, a1 ); }
         
    template<typename T1, typename T2>
        void* operator new( size_t size, T1 a1, T2 a2 ) 
            { return ::operator new( size, a1, a2 ); }
    template<typename T1, typename T2>
        void operator delete( void* block, T1 a1, T2 a2 ) 
            { return ::operator delete( block, a1, a2 ); }
         
    // и т. д.
};