Question

I’m currently working on some C#/C++ code which makes use of invoke. In the C++ side there is a std::vector full of pointers each identified by index from the C# code, for example a function declaration would look like this:

void SetName(char* name, int idx)

But now I’m thinking, since I’m working with pointers couldn’t I sent to C# the pointer address itself then in code I could do something like this:

void SetName(char*name, int ptr)
{
   ((TypeName*)ptr)->name = name;
}

Obviously that’s a quick version of what I’m getting at (and probably won’t compile).

Would the pointer address be guaranteed to stay constant in C++ such that I can safely store its address in C# or would this be too unstable or dangerous for some reason?

Answer 1

Yes, no problem. Native memory allocations never move so storing the pointer in an IntPtr on the C# side is fine. You need some kind of pinvoked function that returns this pointer, then

[DllImport("something.dll", CharSet = CharSet.Ansi)]
void SetName(IntPtr vector, string name, int index);

Which intentionally lies about this C++ function:

void SetName(std::vector<std::string>* vect, const char* name, int index) {
    std::string copy = name;
    (*vect)[index] = copy;
}

Note the usage of new in the C++ code, you have to copy the string. The passed name argument points to a buffer allocated by the pinvoke marshaller and is only valid for the duration of the function body. Your original code cannot work. If you intend to return pointers to vector<> elements then be very careful. A vector re-allocates its internal array when you add elements. Such a returned pointer will then become invalid and you’ll corrupt the heap when you use it later. The exact same thing happens with a C# List<> but without the risk of dangling pointers.