Regras de contagem de referência

Regras de contagem de referência

1. Cada nova cópia de um apontador de interface tem de ser AddRef iria () e cada destruição de um apontador de interface tem de ser Release () iria excepto onde esta regra for accionada permite explicitamente caso contrário.
   
   
   1. parâmetros de saída para funções : O emissor tem AddRef() o parâmetro real, porque irá ser Release () iria pelo destinatário da chamada quando o out-value é armazenado por cima.

            LPOLEOBJECT lpObject;
               .
               .  // Get pointer to IOleObject.
               .
            LPVIEWOBJECT lpView = lpObject;
      
            lpObject->AddRef()
      
            // GetViewObject is a theoretical function that takes a
            // pointer to anything derived from IUnknown, and then
            // returns a pointer to IViewObject in the same variable
            // passed as the parameter. The AddRef() above is needed so
            // that the original pointer to IOleObject is not freed.
      
            GetViewObject(lpView);
      								

   2. a obtenção de uma variável global : A cópia local de um apontador de interface obtido a partir da cópia existente do ponteiro numa variável global tem de ser independentemente referência contada porque chamado funções poderá destruir a cópia no global enquanto a cópia local estiver ainda activa.

            void function()
            {
            // Get a pointer to IOleObject from a global variable.
            LPOLEOBJECT lpOleObject = glpObject;
      
            // This AddRef() is needed so that the interface
            // pointed to by the global variable, glpObject,
            // does not get released by a different part of
            // the applications code.
      
            lpOleObject->AddRef();
               .
               . // use lpOleObject;
               .
            lpOleObject->Release();
            }
      								

   3. novos ponteiros síntese de "fino ar" : função que synthesizes um apontador de interface utilizando conhecimento especial interno em vez de obtê-la de alguns outra origem tem de efectuar um AddRef() inicial no ponteiro recentemente sintetizado. Importante estas rotinas exemplos de rotinas de criação de instância, implementações do IUnknown::QueryInterface e assim sucessivamente.

            STDMETHDOIMP IUnknown::QueryInteface( REFIID iidInterface,
                                               LPVOID FAR *ppvObj)
            {
            *ppvObj = NULL;
            SCODE sc = E_NOINTERFACE;
      
            if (iidInterface == IUnknown)
                {
                *ppvObj = this;
      
                // This AddRef() is needed because a new pointer
                // was just created.
      
                AddRef();
               sc = S_OK;
                }
      
            return ResultFromScode(sc);
            }
      								

   4. devolver uma cópia de um ponteiro armazenada internamente : uma vez que o ponteiro foi devolvido, o destinatário da chamada tem não faz ideia como se relaciona sua vida útil com que a cópia armazenada internamente do ponteiro. Assim, o destinatário da chamada tem AddRef() copiar o ponteiro antes de regressar à mesma.

            // m_lpOleObject is a private member variable of a C++ class.
            // GetOleObject is a member function to return access to this
            // pointer.
      
            void GetOleObject (LPVOID FAR *ppObject)
            {
                *ppObject = m_lpOleObject;
      
                // This AddRef() is needed due to this rule.
      
                m_lpOleObject->AddRef();
             }
      								

2. Conhecimento especial parte de um segmento de código sobre as relações de início e terminações de durações de duas ou mais cópias de um apontador de interface pode permitir que AddRef()/Release() pares ser omitido.
   
   
   1. em parâmetros para funções : A cópia de um apontador de interface passado como parâmetro de real a uma função com uma duração está aninhada em que o ponteiro utilizado para inicializar o valor. Por conseguinte, o parâmetro real não precisa ser separadamente referência contada.

            void function (LPOLEOBJECT lpOleObject)
            {
      
            // Can use lpOleObject in this function
            // without doing AddRef() and Release().
      
            }
      								

   2. parâmetros de saída de funções, incluindo valores de retorno : para definir o parâmetro de saída, a própria função por Rule 1 tem de ter uma cópia estável do apontador de interface. Ao sair, a responsabilidade de libertar o ponteiro é transferida do destinatário da chamada para o autor da chamada. Deste modo, o parâmetro out não necessita de ser referenciado contados.

            LPVIEWOBJECT lpView;
      
            HERROR hErr = lpOleObject->QueryInterface(IID_IViewObject,
                                                      (LPVOID FAR *)lpView);
      
            if (hErr = NOERROR)
                {
                // The QueryInterface succeeded. lpView does not have
                // to be AddRef()'d because it has already been done
                // by the QueryInterface method.
                }
      								

   3. as variáveis locais : A implementação de função tem claramente omniscient conhecimento de durações de cada uma das variáveis ponteiro atribuídas da moldura de pilha. Assim pode utilizar este conhecimento para omitir pares AddRef()/Release() redundantes.

            void function()
            {
            LPOLEOBJECT lpTempObject;
               .
               .
               .
            lpTempObject = lpObject;
               .
               .  // lpTempObject can be used
               .  // without reference counting as long as
               .  // it is known that the lifetime of lpObject
               .  // outside of this function call.
               .
            }
      								

   4. Backpointers : algumas estruturas de dados são de natureza com dois componentes, A e B, cada uma com um ponteiro para o outro. Se a duração de um componente (A) é conhecida para incluir a validade de outros (B), o ponteiro do segundo componente novamente para o primeiro (do B a) tem de não ser referência contada. Muitas vezes, evitar o ciclo caso contrário, deverá ser criado é importante manter o comportamento de libertar adequado.

Voltar ao topo