Partager via

% (suivi des références)

  • Article

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

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 provoque l'incrémentation du nombre de références de l'objet.

  • Une référence native (&) est le résultat obtenu lorsque vous déréférencez un *. Une référence de suivi (%) est le résultat obtenu lorsque vous déréférencez un ^. La seule différence entre & et % est que & est une référence « brute », tandis que % est une référence comptée. Tant que vous avez une référence % à un objet, l'objet reste actif en mémoire.

  • L'opérateur d'accès aux membres point (.) est utilisé pour accéder à un membre de l'objet.

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

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

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

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

Windows Runtime

Une référence de suivi se comporte comme une référence C++ standard comptée. 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 vers lequel elle 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 établissez 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 est impossible d'avoir une référence C++ native à un objet sur le tas récupéré par le garbage collector.

Pour plus d'informations sur les références de suivi en C++/CLI, consultez :

Exemples

Exemple

L'exemple suivant montre comment utiliser une référence de suivi avec des types managés et natifs.

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