Declares a pointer to inside a reference type, but not to the object itself. An interior pointer can point to a reference handle, value type, boxed type handle, member of a managed type, or to an element of a managed array.

cli::interior_ptr<cv_qualifier type> var = &initializer;


  • cv_qualifier
    const or volatile qualifiers.

  • initializer
    A member of a reference type, element of a managed array, or any other object that you can assign to a native pointer.

  • type
    The type of initializer.

  • var
    The name of the interior_ptr variable.


A native pointer is not able to track an item as its location changes on the managed heap, which results from the garbage collector moving instances of an object. In order for a pointer to correctly refer to the instance, the runtime needs to update the pointer to the newly positioned object.

An interior_ptr represents a superset of the functionality of a native pointer. Therefore, anything that can be assigned to a native pointer can also be assigned to an interior_ptr. An interior pointer is permitted to perform the same set of operations as native pointers, including comparison and pointer arithmetic.

An interior pointer can only be declared on the stack. An interior pointer cannot be declared as a member of a class.

Since interior pointers exist only on the stack, taking the address of an interior pointer yields an unmanaged pointer.

interior_ptr has an implicit conversion to bool, which allows for its use in conditional statements.

For information on how to declare an interior pointer that points into an object that cannot be moved on the garbage-collected heap, see pin_ptr.

interior_ptr is in the cli namespace. See cli Namespace for more information.

For more information on interior pointers, see


The following sample shows how to declare and use an interior pointer into a reference type.

// interior_ptr.cpp
// compile with: /clr
using namespace System;

ref class MyClass {
   int data;

int main() {
   MyClass ^ h_MyClass = gcnew MyClass;
   h_MyClass->data = 1;

   interior_ptr<int> p = &(h_MyClass->data);
   *p = 2;

   // alternatively
   interior_ptr<MyClass ^> p2 = &h_MyClass;
   (*p2)->data = 3;

1 2 3


Compiler option: /clr

See Also


Language Features for Targeting the CLR