Anyone?

Yes you are, but unfortunately it's not that simple in ME C++ (things are
different in C++/CLI though).

Here is is a sample that shows you how to handle the calling convention
issue...
Note that this is basically what PInvoke does....but you have more control
(and responsability) here over marshaling the arguments.

#pragma unmanaged
class Native
{
  public:
  void DoSomethingNativeAndCallUsBack( void (__stdcall *ptr) (int))
  {
  int i = 10;
   {
// Call into managed code using the callback pointer passing an int
   ptr(i);
   }
  }
};

// managed code from here
#pragma managed

public __gc class C
{
private:
// private inner non GC class used as thunk to callback into managed code
   __nogc class _C
   {
    private:
    static void __stdcall CallbackProc(int v)
    {
    m_pClass->m_cbProc->Invoke(v);
    return ;
    }
    public:
    void CallNative()
    {
    Native* n = new Native();
   n->DoSomethingNativeAndCallUsBack(_C::CallbackProc);
    }
   };
 _C* m_c;

public:
 __delegate void CbckProc(int v);
  static C* m_pClass = 0;
 C()
 {
  m_pClass = this;
  m_c = new _C();
 }
 ~C()
 {
  delete m_c;
 }
 //Managed callback method
 static void CallBack(int i)
  {
  System::Console::WriteLine(__box(i));
  }
 void DoSomething()
 {
    m_cbProc = new CbckProc(this, &C::CallBack);
    m_c->CallNative();
 }
CbckProc* m_cbProc;
};

int main()
{
  C* c = new C();
  c->DoSomething();
}

Hope this help.

Willy.