One
limitation of a pointer to a fixed array is that you may not reassign
this pointer to any other element of that array using pointer
arithmetic. The following code will not compile since we are
attempting to modify where the fixed pointer,
arrayPtr
, is pointing. The line of code in error
is highlighted and results in a compile-time error:
unsafe
{
int[] intArray = new int[5] {1,2,3,4,5};
fixed(int* arrayPtr = &intArray[0])
{
arrayPtr++;
}
}
We need a way to increment the address stored in the
arrayPtr
to access other elements in the array.
To allow this operation, create a new temporary pointer to the fixed array, shown here:
unsafe { int[] intArray = new int[5] {1,2,3,4,5}; fixed(int* arrayPtr = &intArray[0]) { int* tempPtr = arrayPtr; tempPtr++; } }
By assigning a pointer that points to the fixed pointer
(arrayPtr
), we now have a variable
(tempPtr
) that we can manipulate as we wish.
Any
variables declared in a fixed
statement cannot be
modified or passed as ref
or
out
parameters to other methods. This limitation
can pose a problem when attempting to move a pointer of this type
through the elements of an array. Fixing this problem involves
creating a temporary variable, tempPtr
, that
points to the same memory locations as the pointer declared in the
fixed
statement. Pointer arithmetic can then be
applied to this temporary variable to cause the pointer to point to
any of the elements in the array.
The compiler does not allow passing the pointer declared in the
fixed
statement, arrayPtr
, as a
ref
or out
parameter. However,
the tempPtr
variable can be passed to a method as
a ref
or out
parameter. Passing
pointers by reference or as out
parameters can
easily introduce errors into your code.