Freigeben über

Nachverfolgungsverweisoperator (C++/CLI und C++/CX)

  • Artikel

Ein Nachverfolgungsverweis (%) verhält sich wie ein gewöhnlicher C++-Verweis (&), außer dass beim Zuweisen eines Objekts zu einem Nachverfolgungsverweis die Referenzanzahl des Objekts erhöht wird.

Alle Plattformen

Ein Nachverfolgungsverweis verfügt über die folgenden Eigenschaften.

  • Die Zuweisung eines Objekts zu einem Nachverfolgungsverweis bewirkt, dass die Verweisanzahl des Objekts erhöht wird.

  • Wenn Sie einen * dereferenzieren, ist das Ergebnis ein nativer Verweis (&). Wenn Sie einen ^ dereferenzieren, ist das Ergebnis ein Nachverfolgungsverweis (%). Solange Sie über einen % zu einem Objekt verfügen, bleibt das Objekt im Speicher erhalten.

  • Der Punktzugriffsoperator (.) für Member wird verwendet, um auf einen Member des Objekts zuzugreifen.

  • Nachverfolgungsverweise gelten für Werttypen und Handles (beispielsweise String^).

  • Einem Nachverfolgungsverweis kann kein Null- oder nullptr Wert zugewiesen werden. Ein Nachverfolgungsverweis kann einem anderen gültigen Objekt so oft wie erforderlich neu zugewiesen werden.

  • Ein Nachverfolgungsverweis kann nicht als unärer Adressenübernahmeoperator (Take-Address-Operator) verwendet werden.

Windows-Runtime

Ein Nachverfolgungsverweis verhält sich wie ein Standard-C++-Verweis, und zwar mit Ausnahme, dass ein % per Referenzzählung behandelt wird. Der folgende Ausschnitt zeigt die Konvertierung zwischen %- und ^-Typen:

Foo^ spFoo = ref new Foo();
Foo% srFoo = *spFoo;
Foo^ spFoo2 = %srFoo;

Im folgenden Beispiel wird das Übergeben einer ^-Funktion gezeigt, die ein % aufweist.

ref class Foo sealed {};

    // internal or private
    void UseFooHelper(Foo% f)
    {
        auto x = %f;
    }

    // public method on ABI boundary
    void UseFoo(Foo^ f)
    {
        if (f != nullptr) { UseFooHelper(*f); }
    }

Übersicht: Common Language Runtime (CLR)

Sie können in C++/CLI einen Nachverfolgungsverweis auf ein Handle verwenden, um eine Bindung zu einem Objekt eines CLR-Typs auf dem Heap der Garbage Collection herzustellen.

In der CLR wird der Wert einer Nachverfolgungsverweisvariablen automatisch aktualisiert, wenn der Garbage Collector das referenzierte Objekt verschiebt.

Ein Nachverfolgungsverweis kann nur auf dem Stapel deklariert werden. Ein Nachverfolgungsverweis kann kein Klassenmember sein.

Die Verwendung eines systemeigenen C++-Verweises auf ein Objekt auf dem Heap der Garbage Collection ist nicht möglich.

Weitere Informationen über Nachverfolgungsverweise in C++/CLI finden Sie unter:

Beispiele

Das folgende Beispiel für C++/CLI veranschaulicht, wie ein Nachverfolgungsverweis mit systemeigenen und verwalteten Typen verwendet wird.

// tracking_reference_1.cpp
// compile with: /clr
ref class MyClass {
public:
   int i;
};

value struct MyStruct {
   int k;
};

int main() {
   MyClass ^ x = ref new MyClass;
   MyClass ^% y = x;   // tracking reference handle to reference object

   int %ti = x->i;   // tracking reference to member of reference type

   int j = 0;
   int %tj = j;   // tracking reference to object on the stack

   int * pi = new int[2];
   int % ti2 = pi[0];   // tracking reference to object on native heap

   int *% tpi = pi;   // tracking reference to native pointer

   MyStruct ^ x2 = ref new MyStruct;
   MyStruct ^% y2 = x2;   // tracking reference to value object

   MyStruct z;
   int %tk = z.k;   // tracking reference to member of value type

   delete[] pi;
}

Das folgende Beispiel für C++/CLI veranschaulicht, wie ein Nachverfolgungsverweis an ein Array gebunden wird.

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

int main() {
   array<int> ^ a = ref new array<Int32>(5);
   a[0] = 21;
   Console::WriteLine(a[0]);
   array<int> ^% arr = a;
   arr[0] = 222;
   Console::WriteLine(a[0]);
}

21
222