Opérateur de référence de suivi (C++/CLI et C++/CX)Tracking Reference Operator (C++/CLI and C++/CX)

Une référence de suivi ( % ) se comporte comme une référence C++ ordinaire ( & ), sauf que lorsqu’un objet est assigné à une référence de suivi, le nombre de références de l’objet est incrémenté.A tracking reference (%) behaves like an ordinary C++ reference (&) except that when an object is assigned to a tracking reference, the object's reference count is incremented.

Toutes les plateformesAll Platforms

Une référence de suivi possède les caractéristiques suivantes.A tracking reference has the following characteristics.

  • L’assignation d’un objet à une référence de suivi entraîne l’incrémentation du décompte de références de l’objet.Assignment of an object to a tracking reference causes the object's reference count to be incremented.

  • Une référence native (&) est le résultat obtenu lorsque vous déréférencez un *.A native reference (&) is the result when you dereference a *. Une référence de suivi (%) est le résultat obtenu lorsque vous déréférencez un ^.A tracking reference (%) is the result when you dereference a ^. Tant que vous avez une référence % à un objet, l’objet reste actif en mémoire.As long as you have a % to an object, the object will stay alive in memory.

  • L'opérateur d'accès aux membres point (.) est utilisé pour accéder à un membre de l'objet.The dot (.) member-access operator is used to access a member of the object.

  • Les références de suivi sont valides pour les types valeur et les descripteurs (par exemple String^).Tracking references are valid for value types and handles (for example String^).

  • Une référence de suivi ne peut pas être assignée à une valeur null ou nullptr .A tracking reference cannot be assigned a null or nullptr value. Une référence de suivi peut être réassignée à un autre objet valide autant de fois que nécessaire.A tracking reference may be reassigned to another valid object as many times as required.

  • Une référence de suivi ne peut pas être utilisée comme opérateur de prise d'adresse unaire.A tracking reference cannot be used as a unary take-address operator.

Windows RuntimeWindows Runtime

Une référence de suivi se comporte comme une référence C++ standard, sauf qu'un % inclus un comptage des références.A tracking reference behaves like a standard C++ reference, except that a % is reference-counted. L'extrait de code suivant montre comment effectuer une conversion entre les types % et ^ :The following snippet shows how to convert between % and ^ types:

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

L'exemple suivant montre comment passer un ^ en fonction qui accepte un %.The following example shows how to pass a ^ to a function that takes a %.

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

Common Language RuntimeCommon Language Runtime

En C++/CLI, vous pouvez utiliser une référence de suivi à un handle quand vous établissez une liaison à un objet de type CLR sur le tas récupéré par le garbage collector.In C++/CLI, you can use a tracking reference to a handle when you bind to an object of a CLR type on the garbage-collected heap.

Dans le CLR, la valeur d'une variable de référence de suivi est mise à jour automatiquement chaque fois que le garbage collector déplace l'objet référencé.In the CLR, the value of a tracking reference variable is updated automatically whenever the garbage collector moves the referenced object.

Une référence de suivi peut être déclarée uniquement sur la pile.A tracking reference can be declared only on the stack. Une référence de suivi ne peut pas être membre d'une classe.A tracking reference cannot be a member of a class.

Il est impossible d'avoir une référence C++ native à un objet sur le tas récupéré par le garbage collector.It is not possible to have a native C++ reference to an object on the garbage-collected heap.

Pour plus d'informations sur les références de suivi en C++/CLI, consultez :For more information about tracking references in C++/CLI, see:

ExemplesExamples

L'exemple suivant pour C++/CLI montre comment utiliser une référence de suivi avec des types managés et natifs.The following sample for C++/CLI shows how to use a tracking reference with native and managed types.

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

L'exemple suivant pour C++/CLI montre comment lier une référence de suivi à un tableau.The following sample for C++/CLI shows how to bind a tracking reference to an array.

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