pin_ptr (C++/CLI)

Deklariert einen festen Zeiger, der nur mit der Common Language Runtime verwendet wird.

Alle Laufzeiten

(Es gibt keine Hinweise für diese Sprachfunktion, die auf allen Laufzeiten beziehen).

Windows Runtime

(Diese Sprachfunktion wird nicht in die Windows Runtime unterstützt.)

Common Language Runtime

Ein fester Zeiger ist ein innerer Zeiger, der verhindert, dass das Objekt an, das beweglichem auf dem Heap der Garbage Collection dargestellt wird.Das heißt, der Wert eines festen Zeigers von der Common Language Runtime nicht geändert.Dies ist erforderlich, wenn Sie die Adresse einer verwalteten Klasse an eine nicht verwaltete Funktion übergeben, damit die Adresse nicht unerwartet während der Auflösung des nicht verwalteten Funktionsaufrufs ändert.

Syntax

[cli::]pin_ptr<cv_qualifier type> var = &initializer;

Parameter

• cv_qualifier
  const oder volatile Qualifizierer.Standardmäßig ist ein fester Zeiger volatile.Es ist kein Fehler, jedoch redundant einen festen Zeiger deklarieren volatile.

• type
  Der Typ von initializer.

• Variable
  Der Name der pin_ptr-Variablen.

• Initialisierung
  Ein Member eines Verweistyps des Elements eines verwalteten Arrays oder eines anderen Objekts, den Sie an einen systemeigenen Zeiger zuweisen können.

Hinweise

pin_ptr stellt eine Obermenge der Funktionalität eines systemeigenen Zeiger dar.Daher kann alles, das auf einem systemeigenen Zeiger zugewiesen werden kann, auch pin_ptr zugewiesen werden.Ein innerer Zeiger kann den gleichen Satz von Vorgängen wie systemeigene Zeiger, einschließlich Vergleich und Zeigerarithmetik auszuführen.

Ein Objekt oder ein Unterobjekt einer verwalteten Klasse können fixiert werden. In diesem Fall wird die Common Language Runtime sie nicht während der Garbage Collection verschoben wird.Die Verwendung dieses Prinzipals einen Zeiger auf den verwalteten Daten als Parameter eines nicht verwalteten Funktionsaufrufs zu übergeben.Während eines Auflistung zyklus überprüft die Laufzeit die Metadaten, die für den festen Zeiger erstellt und ändert nicht das Element, das er verweist.

Pins eines Objekts auch anheften Felder, deren Wert d. h. die Felder des Grundtyps oder des Werttyps.Die Felder, indem Handles (%) deklariert wurden, werden nicht fixiert nachverfolgt.

Das Fixieren eines Unterobjekts, das in einem verwalteten Objekt definiert wurde, hat Auswirkungen des Anheftens des vollständigen Objekts.

Wenn die feste Zeiger an dem Punkt wieder in einen neuen Wert zugewiesen wird, gilt die vorherige Instanz, die verwiesen wird, nicht mehr als fixiert.

Ein Objekt ist fixiert, nur während pin_ptr darauf zeigt.Das Objekt wird nicht mehr fixiert, fester Zeiger sein, wenn mehr im Gültigkeitsbereich befindet, oder nullptr festgelegt wird.Nachdem pin_ptr mehr im Gültigkeitsbereich befindet, kann das Objekt fixiert wurde, vom Garbage Collector den Heap verschoben werden.Keine systemeigenen Zeiger, die nach wie vor auf das Objekt verweisen, werden nicht aktualisiert, und einen davon dereferenzierend, könnten eine nicht behebbare Ausnahme auslösen.

Wenn keine feste Zeiger auf das Objekt (alle festen Zeiger erloschen den Gültigkeitsbereich, wurden dem Punkt wieder andere Objekte zugewiesen wurden oder nullptr zugewiesen), zeigen, wird das Objekt fixiert nicht garantiert werden.

Ein fester Zeiger kann zu einem Verweisen behandelt, ein Werttyp oder geschachteltes Typhandle, Member eines verwalteten Typs zeigen oder ein Element eines verwalteten Arrays.Es kann nicht auf einen Verweistyp veranschaulichen.

Das Ändern der Adresse von pin_ptr, die zu einem systemeigenen Objekt verweist, führt ein nicht definiertes Verhalten.

Feste Zeiger können als nicht statische lokale Variablen nur auf dem Stapel deklariert werden.

Feste Zeiger können nicht verwendet werden:

• Funktionsparameter

• der Rückgabetyp einer Funktion

• Member einer Klasse

• Der Zieltyp der Typumwandlung.

pin_ptr befindet sich im cli-Namespace.Weitere Informationen finden Sie unter Platform-, default- und cli-Namespaces (Komponentenerweiterungen für C++).

Weitere Informationen über innere Zeiger finden Sie unter interior_ptr (C++/CLI).

Weitere Informationen über feste Zeiger finden Sie unter Gewusst wie: Anheften von Zeigern und Arrays und Gewusst wie: Deklarieren von festen Zeigern und Werttypen.

Anforderungen

Compileroption: /clr

Beispiele

Beispiel

Im folgenden Beispiel wird pin_ptr, um die Position des ersten Elements in einem Array zu beschränken.

// pin_ptr_1.cpp
// compile with: /clr 
using namespace System;
#define SIZE 10

#pragma unmanaged
// native function that initializes an array
void native_function(int* p) {
   for(int i = 0 ; i < 10 ; i++)
    p[i] = i;
}
#pragma managed

public ref class A {
private:
   array<int>^ arr;   // CLR integer array

public:
   A() {
      arr = gcnew array<int>(SIZE);
   }

   void load() {
   pin_ptr<int> p = &arr[0];   // pin pointer to first element in arr
   int* np = p;   // pointer to the first element in arr
   native_function(np);   // pass pointer to native function
   }

   int sum() {
      int total = 0;
      for (int i = 0 ; i < SIZE ; i++)
         total += arr[i];
      return total;
   }
};

int main() {
   A^ a = gcnew A;
   a->load();   // initialize managed array using the native function
   Console::WriteLine(a->sum());
}

Output

Beispiel

Das folgende Beispiel zeigt, dass ein innerer Zeiger auf einen festen Zeiger konvertiert werden kann und dass der Rückgabetyp den Adressoperator (&) ein innerer Zeiger ist, wenn der Operand auf dem verwalteten Heap befindet.

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

ref struct G {
   G() : i(1) {}
   int i;
};

ref struct H {
   H() : j(2) {}
   int j;
};

int main() {
   G ^ g = gcnew G;   // g is a whole reference object pointer
   H ^ h = gcnew H;

   interior_ptr<int> l = &(g->i);   // l is interior pointer

   pin_ptr<int> k = &(h->j);   // k is a pinning interior pointer

   k = l;   // ok
   Console::WriteLine(*k);
};

Output

Beispiel

Das folgende Beispiel zeigt, dass ein fester Zeiger auf einen anderen Typ konvertiert werden kann.

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

ref class ManagedType {
public:
   int i;
};

int main() {
   ManagedType ^mt = gcnew ManagedType;
   pin_ptr< int > pt = &mt->i;
   *pt = 8;
   Console::WriteLine(mt->i);

   char *pc = ( char* ) pt;
   *pc = 255;
   Console::WriteLine(mt->i);
}

Output