Operator odwołania śledzenia (C++/CLI i C++/CX)

  • Artykuł

Odwołanie do śledzenia (%) zachowuje się jak zwykłe odwołanie W++ (&), z tą różnicą, że gdy obiekt jest przypisany do odwołania do śledzenia, liczba odwołań do obiektu jest zwiększana.

Wszystkie platformy

Odwołanie do śledzenia ma następujące cechy.

  • Przypisanie obiektu do odwołania śledzenia powoduje, że liczba odwołań do obiektu jest zwiększana.

  • Odwołanie natywne (&) jest wynikiem w przypadku wyłudzenia .* Odwołanie do śledzenia (%) jest wynikiem w przypadku wyłudzenia .^ Tak długo, jak masz % obiekt do obiektu, obiekt pozostanie w pamięci.

  • Operator dot (.) dostępu do składowej służy do uzyskiwania dostępu do elementu członkowskiego obiektu.

  • Odwołania do śledzenia są prawidłowe dla typów wartości i dojść (na przykład String^).

  • Nie można przypisać odwołania do śledzenia o wartości null ani nullptr wartości. Odwołanie do śledzenia może zostać ponownie przydzielone do innego prawidłowego obiektu tyle razy, ile jest to wymagane.

  • Nie można użyć odwołania do śledzenia jako jednoargumentowego operatora take-address.

Środowisko wykonawcze systemu Windows

Odwołanie do śledzenia zachowuje się jak standardowe odwołanie w języku C++, z tą różnicą, że liczba % jest zliczona. Poniższy fragment kodu przedstawia sposób konwertowania między typami % i ^:

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

W poniższym przykładzie pokazano, jak przekazać element ^ do funkcji, która przyjmuje wartość %.

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); }
    }

środowiska uruchomieniowe w trakcie wykonania

W języku C++/CLI można użyć odwołania śledzenia do uchwytu po powiązaniu z obiektem typu CLR na stercie zbieranym przez śmieci.

W clR wartość zmiennej referencyjnej śledzenia jest aktualizowana automatycznie za każdym razem, gdy moduł odśmiecenia pamięci przenosi przywołyany obiekt.

Odwołanie do śledzenia można zadeklarować tylko na stosie. Odwołanie do śledzenia nie może być elementem członkowskim klasy.

Nie można mieć natywnego odwołania C++ do obiektu na stercie zbieranej przez śmieci.

Aby uzyskać więcej informacji na temat śledzenia odwołań w języku C++/interfejsie wiersza polecenia, zobacz:

Przykłady

W poniższym przykładzie dla języka C++/CLI pokazano, jak używać odwołania do śledzenia z typami natywnymi i zarządzanymi.

// 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;
}

Poniższy przykład dla języka C++/CLI przedstawia sposób powiązania odwołania śledzenia do tablicy.

// 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