Hi David,

I do not necessarily agree with the other statements. IMO there *is* a need
for special care with pin pointers:

Let's start with a dumb scenario:

  unsigned char* NeverDoThis(array<unsigned char>^ arr)
  {
     pin_ptr<unsigned char> pp(&arr[0]);
     return pp;
  }

In this case, you pin a pointer to a managed array, use the standard
conversion to get a native pointer, and return the native pointer to the
caller. After the method has returned, the array is no longer pinned and
could be relocated, but the native pointer would still refer to the old
location. Let's have a look at a less dumb scenario:

Assume you have a managed array:
 array<unsinged char>^ arr = GetArrayFromSomeWhere();

Further assume you want to pass a native pointer to the array to a native
function like this one:

 void DoSth(unsigned char*);

To achieve this, you could write:
{
 pin_ptr<unsigned char> pp(&arr[0]);
 DoSth(pp);
}

Is this code safe? Well that depends on the implementation of DoSth. If
DoSth stores the native pointer to access the array after the call, this
code as a problem, because the pinnng time ends after the pointer left
scope.

Marcus Heege