Ok, thanks, that's a good example of where interior pointers can simplify things. But you could do similarly with just handles if you have an array of 'handle to typeX' even if its not quite as nice a solution. (Sorry I'm not sure how to use the code tag and ignore HTML so the array type is shown.) #include "stdafx.h" using namespace System; // Can multiply the array elements when the array type is handle to type // rather than needing interior pointers. // A little silly with int due to boxing costs but imagine with an array of // ref class objects where you do perform some useful change to each element void MulArray( array^ data, int value ) { for each(int^% i in data) { *i *= value; } } // Tracking references point to the whole managed object. // Using a tracking reference here does not make much sense since using a // tracking handle has the same affect in this case. void PrintArray( array^ vals ) { for each (int val in vals) { Console::WriteLine(val); } } int main(array ^args) { // Tracking handles refer to the whole managed object. // They can be initialized with gcnew. array^ values = { 1, 2, 3, 4, 5 }; MulArray(values, 2); PrintArray(values); return 0; } Now I understand why you'd want your version in some cases where you're being passed an array^ that you didn't choose to create. In theory you could create a new array (of array^) to copy the array^ to use with my version if you wanted to avoid interior pointers and make the code verifiable. I'm just trying to draw a solid line in my mind dividing the uses of handles and interior pointers. Like I said (and you just showed), they can be useful for pointer semantics. But you can still find a way to avoid them and use handles to point to interior members. So are the only time they're absolutely necessary are when you must have pointer semantics and in some interop scenarios (where native pointers can convert implicitly to interior pointers but not handles)? They can simplify some situations where you're pointing to interior members of a ref class but you can still get around doing so via handles (even if it may not be as elegant and performant as the interior pointer solution).
