Recipe 16.4 Manipulating a Pointer to a Fixed Array

Problem

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.

Solution

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.

Discussion

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.

See Also

See the "unsafe" and "fixed" keywords in the MSDN documentation.