Is it safe to keep C++ pointers in C#?

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

In C#, you don't need to use a pointer here, you can just use a plain C# string.

[DllImport(...)]
extern void SetName(string name, int id);

This works because the default behavior of strings in p/invoke is to use MarshalAs(UnmanagedType.LPStr) , which converts to a C-style char*. You can mark each argument in the C# declaration explicitly if it requires some other way of being marshalled, eg, [MarshalAs(UnmanagedType.LPWStr)] , for an arg that uses a 2-byte per character string.

The only reason to use pointers is if you need to retain access to the data pointed to after you've called the function. Even then, you can use out parameters most of the time.

You can p/invoke basically anything without requiring pointers at all (and thus without requiring unsafe code, which requires privileged execution in some environments).

Answer 2

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.

Answer 3

I think it's stable till you command C++ code and perfectly aware what he does, and other developers that work on the same code know about that danger too.

So by my opinion, it's not very secure way of architecture, and I would avoid it as much as I can.

Regards.

Answer 4

The C# GC moves things, but the C++ heap does not move anything- a pointer to an allocated object is guaranteed to remain valid until you delete it. The best architecture for this situation is just to send the pointer to C# as an IntPtr and then take it back in C++.

It's certainly a vastly, incredibly better idea than the incredibly BAD, HORRIFIC integer cast you've got going there.