Question

Suppose I write the following code:

public ref class Data
{
public:
    Data()
    {
    }

    Int32 Age;
    Int32 year;
};

public void Test()
{
    int age = 30;  
    Int32 year = 2010;  
    int* pAge = &age;  
    int* pYear = &year;


    Data^ data = gcnew Data();
    int* pDataYear = &data->Year; // pData is interior pointer and the compiler will throw error
}

If you compile the program, the compiler will throw error:
error C2440: ‘initializing’ : cannot convert from ‘cli::interior_ptr’ to ‘int *’
So I learned the “&data->Year” is a type of interior pointer.
UPDATES: I tried to use “&(data->Year)”, same error.

But how about pAge and pYear?
Are they native pointers, interior pointers or pinned pointers??

If I want to use them in the following native function:

void ChangeNumber(int* pNum);

Will it be safe to pass either pAge or pYear?

Answer 1

They (pAge and pYear) are native pointers, and passing them to a native function is safe. Stack variables (locals with automatic storage lifetime) are not subject to being rearranged by the garbage collector, so pinning is not necessary.

Copying managed data to the stack, then passing it to native functions, solves the gc-moving-managed-data-around problem in many cases (of course, don’t use it in conjunction with callbacks that expect the original variable to be updated before your wrapper has a chance to copy the value back).

To get a native pointer to managed data, you have to use a pinning pointer. This can be slower than the method of copying the value to the stack, so use it for large values or when you really need the function to operate directly on the same variable (e.g. the variable is used in callbacks or multi-threading).

Something like:

pin_ptr<int> p = &mgd_obj.field;

See also the MSDN documentation