void Obj::release()
{
   delete this;
}

class BaseObj
{
public:
    __stdcall BaseObj(){};
    virtual __stdcall ~BaseObj()
    {
    }
    virtual void __stdcall Release()
    {
        delete this;
    }
};

extern "C" __declspec(dllexport) BaseObj *__stdcall obj_new()
{
    return new BaseObj;
}

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
                     )
{
    return TRUE;
}

#include <stdio.h>
#include <conio.h>
#include <windows.h>

class BaseObj
{
public:
    __stdcall BaseObj(){};
    virtual __stdcall ~BaseObj()
    {
    }
    virtual void __stdcall Release()
    {
        delete this;
    }
};

extern "C" __declspec(dllimport) BaseObj *__stdcall obj_new();

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
                     )
{
    return TRUE;
}


int main(int argc, char* argv[])
{
    typedef BaseObj *(__stdcall *tobj_new)();
    tobj_new pobj_new = (tobj_new)::GetProcAddress(::LoadLibrary(TEXT("testmemdll.dll")), "_obj_new@0");

    if (!pobj_new)
    {
        printf("dll or function not found\n");
        getch();
        return -1;
    }

    printf("Press '1' to use delete or '2' to use Release\n");
    switch (getch())
    {
    case '1':
        {
            for(;;)
            {
                BaseObj *obj = pobj_new();
                delete obj;
                delete new char[256];
            }
        }
        break;
    case '2':
        {
            for(;;)
            {
                BaseObj *obj = pobj_new();
                obj->Release();
                delete new char[256];
            }
        }
        break;
    }

    return 0;
}

Custom deallocators allow a factory function returning a shared_ptr to insulate the user from its memory allocation strategy. Since the deallocator is not part of the type, changing the allocation strategy does not break source or binary compatibility, and does not require a client recompilation. For example, a "no-op" deallocator is useful when returning a shared_ptr to a statically allocated object, and other variations allow a shared_ptr to be used as a wrapper for another smart pointer, easing interoperability.

D>>shared_ptr::pn::get_deleter(), виртуальная функция удалает тем delete каким был создан (хитро там намешано )

А>Хм ну если так то тогда мона юзать shared_ptr

class IBaseClass
{
public:
   virtual ~IBaseClass() =0 {};
};

// start =============== native.h ====================
class example
{
public:
    virtual ~example() = 0 {}
};

example* create_example();
// end =============== native.h ====================


// start =============== native.cpp ====================
#include"native.h"

#include <memory.h>
#include <stdlib.h>
#include <stdio.h>



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

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


class example2 : public example 
{
    int i;
};


example* create_example()
{
   return new example2;
}
// end =============== native.cpp ====================


// start =============== test2.cpp ====================
#include <memory.h>
#include <stdlib.h>
#include <stdio.h>


#include"native.h"

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

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


class example3 : public example 
{
    int i;
};



int main(int argc, char* argv[])
{
    example* e = create_example();
    delete e;


    example* e3 = new example3;
    delete e3;


    return 0;
}
// end =============== test2.cpp ====================

// вызов деструктора:
   p->CDummy::~CDummy();
// или 
   (p->*vtbl[destructor_index])();

// освобождение памяти.
   ::operator delete(p);

CDummy::~CDummy_Aux()
{
   this->CDummy::~CDummy();
   ::operator delete(this);
}

   (p->*vtbl[destructor_index])();

BP>А delete кто будет автоматически вызывать ? Пушкин ?

BP>>>Очень даже way

struct test {};

shared_ptr<test> p (new test);
shared_array<test> p (new test[10]);

NB>struct test {};

NB>shared_ptr<test> p (new test);
NB>shared_array<test> p (new test[10]);
NB>

struct test {};
void release_test(test *t)
{
t->Release();
}

shared_ptr<test> p (new test, release_test);
shared_array<test> p (new test[10], release_test);

class test 
{
protected:
    virtual ~test(){};

public:
    test(){};
 void Release()
 {
 delete this;
 };

static void ReleaseIt(test *it)
{
it->Release();
}

};

boost::shared_ptr<test> p (new test, test::ReleaseIt);
boost::shared_array<test> a (new test[10], test::ReleaseIt);

IObjectFromDll.h:

class IObjectFromDll
{
protected:
    virtual ~IObjectFromDll(){} = 0;

public:
 virtual void Release() = 0;

inline static void ReleaseIt(test *it)
{
it->Release();
}

};

Executable.cpp:

boost::shared_ptr<test> p (ObtainObjectFromDll(), test::ReleaseIt);

А>class test 
А>{
А>protected:
А>    virtual ~test(){};

А>public:
А>    test(){};
А> void Release()
А> {
А> delete this;
А> };

А>static void ReleaseIt(test *it)
А>{
it->>Release();
А>}

А>};

А>boost::shared_ptr<test> p (new test, test::ReleaseIt);
А>boost::shared_array<test> a (new test[10], test::ReleaseIt);

//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 ); }
         
    // и т. д.
};