Recipe 16.3 Navigating Arrays

Problem

You need to iterate through the elements of a single-dimensional, multidimensional, or jagged array using a pointer to that array.

Solution

To enable iteration, we create an unsafe pointer that points to an array. The manipulation of the array can then be performed through this pointer.

To create a pointer to a single-dimension array, declare and initialize the array:

int[] intArray = new int[5] {1, 2, 3, 4, 5};

and then set a pointer, arrayPtr, to the address of the first element in this array (we must use the fixed keyword to pin the array in the managed heap so that the garbage collector does not move it):

fixed(int* arrayPtr = &intArray[0])

Note that this line could also be written as:

fixed(int* arrayPtr = intArray)

without any address of (&) operator or indexer. This is because the array variable always points to the first element, similar to how C++ array pointers operate.

The following code creates and initializes a pointer to a single-dimension array and then displays the last item in that array:

unsafe
{
    int[] intArray = new int[5] {1, 2, 3, 4, 5};
    fixed(int* arrayPtr = &intArray[0])
    {
        Console.WriteLine(*(arrayPtr + 4)); //Display the last value '5'
    }
}

Creating a pointer to an array of enumeration values is very similar:

unsafe
{
    Colors[] intArray = new Colors[2] {Colors.Red, Colors.Blue};
    fixed(Colors* arrayPtr = &intArray[0])
    {
        // Use arrayPtr here
    }
}

where Colors is declared as follows:

public enum Colors{Red, Green, Blue}

The last element of the array can then be displayed with the following code:

Console.WriteLine(*(arrayPtr + intArray.GetLength(0) - 1));

Creating a pointer to a multidimensional array is performed by declaring and initializing a multidimensional array:

int[,] intMultiArray = new int[2,5] {{1,2,3,4,5},{6,7,8,9,10}};

and then setting a pointer to the address of the first element in this array:

fixed(int* arrayPtr = &intMultiArray[0,0])

For example, the following code creates and initializes a pointer to a multidimensional array and then displays the last item in that array:

unsafe
{
    int[,] intMultiArray = new int[2,5] {{1,2,3,4,5},{6,7,8,9,10}};
    fixed(int* arrayPtr = &intMultiArray[0,0])
    {
        Console.WriteLine(*(arrayPtr + 9)); //Display the last value '10'
    }
}

A jagged array can be pointed to as well, but it is much harder to navigate this type of array using a pointer. This code creates and initializes a pointer to a jagged array and then displays each item in that array:

unsafe
{ 
    int[][] intJaggedArray = new int[3][];
    intJaggedArray[0] = new int[2] {100,200};
    intJaggedArray[1] = new int[3] {300,400,500};
    intJaggedArray[2] = new int[4] {600,700,800,900};
    fixed(int* arrayPtr = &intJaggedArray[0][0])
    {
        for(int counter = -3; counter <= 15; counter++)
        {
            Console.WriteLine(*(arrayPtr + counter)); 
        }
    }
}

This code creates and initializes a pointer to a jagged array whose second array is defined as a multidimensional array, and then displays each item in that array:

unsafe
{ 
    int[][,] intJaggedArray2 = new int[3][,];
    intJaggedArray2[0] = new int[2,1] {{100},{200}};
    intJaggedArray2[1] = new int[3,1] {{300},{400},{500}};
    intJaggedArray2[2] = new int[4,1] {{600},{700},{800},{900}};
    fixed(int* arrayPtr = &intJaggedArray2[0][0,0])
    {
        for(int counter = -5; counter <= 23; counter++)
        {
            Console.WriteLine(*(arrayPtr + counter)); 
        }
    }
}

See Also

See the "Multidimensional Arrays" and "Jagged Arrays" topics and the "Unsafe at the Limit" article in the MSDN documentation.