Operador de referência de acompanhamento (C++/CLI e C++/CX)

  • Artigo

Uma referência de acompanhamento (%) se comporta como uma referência comum de C++ (&), exceto pelo fato de que quando um objeto é atribuído a uma referência de acompanhamento, a contagem de referências do objeto é incrementada.

Todas as plataformas

Uma referência de acompanhamento possui as características a seguir.

  • A atribuição de um objeto a uma referência de acompanhamento faz com que a contagem de referências do objeto seja incrementada.

  • Uma referência nativa (&) é o resultado quando você desfaz uma referência a um *. Uma referência de acompanhamento (%) é o resultado quando você desfaz uma referência a um ^. Contanto que você tenha um % para um objeto, o objeto permanecerá vivo na memória.

  • O operador de acesso de membro dot (.) é usado para acessar um membro do objeto.

  • As referências de acompanhamento são válidas para tipos de valores e identificadores (por exemplo, String^).

  • Uma referência de acompanhamento não pode receber um valor null ou nullptr. Uma referência de acompanhamento pode ser reatribuída a outro objeto válido quantas vezes for necessário.

  • Uma referência de acompanhamento não pode ser usada como um operador take-address unário.

Windows Runtime

Uma referência de acompanhamento se comporta como uma referência padrão do C++, exceto pelo fato de que um % é contado por referência. O snippet a seguir mostra como converter entre os tipos % e ^:

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

O exemplo a seguir mostra como passar um ^ para uma função que recebe um %.

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 Runtime

No C++ ou na CLI, é possível usar uma referência de acompanhamento para um identificador ao vincular-se a um objeto de um tipo CLR no heap coletado como lixo.

No CLR, o valor de uma variável de referência de acompanhamento é atualizado automaticamente sempre que o coletor de lixo move o objeto referenciado.

Uma referência de acompanhamento pode ser declarada apenas na pilha. Uma referência de acompanhamento não pode ser um membro de uma classe.

Não é possível ter uma referência de C++ nativa para um objeto no heap coletado como lixo.

Saiba mais sobre referências de acompanhamento no C++/CLI em:

Exemplos

O exemplo a seguir para C++/CLI mostra como usar uma referência de acompanhamento com tipos nativos e gerenciados.

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

O exemplo a seguir para C++/CLI mostra como vincular uma referência de acompanhamento a uma matriz.

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