Question

I’m not familiar with C++/CLI so not sure how to free up the memory when using the code below (got the solution here and modified a little):

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

The above code is working when I tested it by writing the char in a text file. Please let me know if I’m missing something (need to clean up pinnedPtr?).

Now when I use it:

char* foobar = ManagedStringToUnmanagedUTF8Char("testing");

//do something with foobar

//do I need to free up memory by deleting foobar here? 
//I tried 'delete foobar' or free(foobar) but it crashes my program

Answer 1

Hans Passant’s comment is correct that the returned pointer to the buffer can be moved in memory by the garbage collector. This is because, when the function stack unwinds, pin_ptr will unpin the pointer.

The solution is to

1. Obtain the System::String buffer and pin it so that the GC cannot
   move it.
2. Allocate memory on the unmanaged heap (or just heap) where
   it is not under the GC’s jurisdiction, and cannot be moved by the
   GC.
3. Copy memory (and convert to desired encoding) from the
   System::String buffer to the buffer allocated on the unmanaged heap.
4. Unpin the pointer so the GC can once again move the System::String
   in memory. (This is done when pin_ptr goes out of the function
   scope.)

Sample code:

char* ManagedStringToUnmanagedUTF8Char(String^ str)
{
    // obtain the buffer from System::String and pin it
    pin_ptr<const wchar_t> wch = PtrToStringChars(str);

    // get number of bytes required
    int nBytes = ::WideCharToMultiByte(CP_UTF8, NULL, wch, -1, NULL, 0, NULL, NULL);
    assert(nBytes >= 0);

    // allocate memory in C++ where GC cannot move
    char* lpszBuffer = new char[nBytes];

    // initialize buffer to null
    ZeroMemory(lpszBuffer, (nBytes) * sizeof(char)); 

    // Convert wchar_t* to char*, specify UTF-8 encoding
    nBytes = ::WideCharToMultiByte(CP_UTF8, NULL, wch, -1, lpszBuffer, nBytes, NULL, NULL);
    assert(nBytes >= 0);

    // return the buffer
    return lpszBuffer;
}

Now, when using:

char* foobar = ManagedStringToUnmanagedUTF8Char("testing");

//do something with foobar

//when foobar is no longer needed, you need to delete it
//because ManagedStringToUnmanagedUTF8Char has allocated it on the unmanaged heap.
delete foobar;