Convert from C++/CLI pointer to native C++ pointer

Question

I have run in to this problem of converting a C++/CLI pointer to a native C++ pointer. Heres the background: I'm writing a windows forms application using C++/CLI. The application makes call into a number of COM Interfaces. When creating an instance (inside of a C++/CLR class) of a object through the COM interface, i pass in (void**)(&provider) as the last argument to CoCreateInstance, as in:

HRESULT CoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, (void**)(&provider));

However, i get the compiler error: cannot convert from cli::interior_ptr<Type> to void ** . I've done som research into this, and it looks like it is a problem of different types of pointers in C++ and C++/CLI. Anyone has any knowledge about this, and maybe a tip on how it could be fixed? Thanx in advance!

First, thanx for all your help!

As Freich suggested, i tried to use the pin_ptr, but this instead made the compiler complaining about problems converting from interior_ptr to pin_ptr. If i instead try to use the interior_ptr as in:

pin_ptr<void *> pinnedPtr = &provider;
CoCreateInstance(CLSID_MSPRProvider, NULL, CLSCTX_LOCAL_SERVER, IID_IMSPRProvider, ( void** )pinnedPtr);

I get cannot convert from interior_ptr to interior_ptr. It all boils down to the problem of converting the interior_ptr to void**. Like this: (void**)interiorPtr, where interiorPtr of course is an interior_ptr. Any ideas in this?

Answer 1

I believe you have to mark the pointer as 'pinned' (in the managed code) and then copy the bytes over to some unmanaged memory region, and then use the pointer to that. For instance, here's a piece of code I once got somewhere which converts a pointer to a managed System::String to an UTF-8 encoded unmanaged std::string:

std::string managedStringToStlString( System::String ^s )
{
    Encoding ^u8 = Encoding::UTF8;
    array<unsigned char> ^bytes = u8->GetBytes( s );
    pin_ptr<unsigned char> pinnedPtr = &bytes[0];
    return string( (char*)pinnedPtr );
}

Note how I've got to get a 'pinned' pointer to the bytes array returned by the GetBytes() function, and then cast that to char* before passing it to the std::string constructor. I believe this is necessary to avoid that the managed memory subsystem moves the bytes array around in memory while I'm copying the bytes into the STL string.

In your case, try replacing

CoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, (void**)(&provider)); 

with

pin_ptr<void *> pinnedPtr = &provider;
CoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, (void**)pinnedPtr); 

and see whether that works.

Answer 2

It's quite some time that I used C++/CLI, but I think you have to pin the pointer.

Answer 3

Is the memory pointed to expected to be valid beyond the call to CoCreateInstance()?

As Frerich and Achim alluded to, you can get a raw pointer to the memory, without fear of the memory being relocated, by "pinning" it and getting an interior pointer. You usually do this with the pin_ptr template (see Frerich post for an example).

However, pin_ptr is deliberately only usable on the stack. You cannot use it as member variable or a global, and you can't pass it as an argument or return value. The memory is unpinned when it leaves scope.

So if the memory is only required to be valid during the call to CoCreateInstance() then pin_ptr is the way to go. If not then you will have to take a copy of the memory and pass that on to CoCreateInstance()