Opérateur de référence de suivi (extensions du composant C++)

Une référence de suivi (%) se comporte comme une référence de ordinaires C++ (&) mais que lorsqu'un objet est assigné à une référence de suivi, le nombre de références de l'objet est incrémenté.

Toutes les plateformes

Une référence de suivi possède les caractéristiques suivantes.

• L'assignation d'un objet à une référence de suivi entraîne le nombre de références de l'objet d'être incrémenté.

• Une référence native (et) est le résultat lorsque vous déréférencez a *.Une référence de suivi (%) est le résultat lorsque vous déréférencez un ^.La seule différence entre et est que % où et est une référence « brut », % est une référence des références numérotée.Tant que vous avez un % à un objet, l'objet reste actif dans la mémoire.

• L'opérateur d'accès de membre de point (.) permet d'accéder à un membre de l'objet.

• Une référence de suivi peut être déclaré uniquement sur la pile.Une référence de suivi ne peut pas être un membre d'une classe.

• Les suivis des références sont valides pour les types valeur et les handles (par exemple String^).

• Une référence de suivi ne peut pas être assigné une valeur null ou d' nullptr .Une référence de suivi peut être réassigné à un autre objet valide autant de fois que nécessaire.

• Une référence de suivi ne peut pas être utilisé comme opérateur unaire de prise- adresse.

Windows Runtime

Une référence de suivi se comporte comme une référence standard des références numérotée C++.Pour plus d'informations sur les références C++, consultez Références (C++).

L'exemple suivant montre comment utiliser une référence de suivi pour modifier le contenu de l'objet qu'il pointe.

/ZW
using namespace Platform;
int main()
{
array<String^> ^arr = ref new array<String^>(10);
    int i = 0;

    for(int i = 0; i < 10; ++i){ 
        String^& s = arr[i];
        s = i++.ToString(); // changes the array content
    }
}

Common Language Runtime

Vous pouvez utiliser une référence de suivi à un handle lorsque vous créez une liaison à un objet d'un type CLR sur le tas récupéré par le garbage collector.

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é.

Il n'est pas possible d'avoir une référence C++ natif à un objet sur le tas récupéré par le garbage collector.

Pour plus d'informations sur les suivis des références dans C++/CLI, consultez :

• Comment : Types de passage par référence CLR avec aux références

• Comment : suivis des références et types valeur d'utilisation

• Comment : suivis des références et pointeurs intérieurs d'utilisation

• Comment : Le modèle d'Écriture des fonctions qui prennent le natif, la valeur, ou les paramètres de référence

Exemples

Exemple

L'exemple suivant montre comment utiliser une référence de suivi avec du code natif et les types managés.

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

Exemple

L'exemple suivant montre comment lier une référence de suivi à un tableau.

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

Sortie