Exceções: alterações nas macros de exceção na versão 3.0

Este é um tópico avançado.

No MFC versão 3.0 e posterior, as macros de tratamento de exceções foram alteradas para usar exceções C++. Este artigo informa como essas alterações podem afetar o comportamento do código existente que usa as macros.

Este artigo aborda os seguintes tópicos:

• Tipos de exceção e a macro CATCH

• Re-lançando exceções

Tipos de exceção e a macro CATCH

Em versões anteriores do MFC, a macro CATCH usava informações de tipo de tempo de execução do MFC para determinar o tipo de uma exceção; o tipo da exceção é determinado, em outras palavras, no site catch. Com exceções de C++, no entanto, o tipo da exceção é sempre determinado no site de lançamento pelo tipo do objeto de exceção que é lançado. Isso causará incompatibilidades no caso raro em que o tipo do ponteiro para o objeto gerado difere do tipo do objeto gerado.

O exemplo a seguir ilustra a consequência dessa diferença entre o MFC versão 3.0 e versões anteriores:

TRY
{
   THROW((CException*) new CCustomException());
}
CATCH(CCustomException, e)
{
   TRACE("MFC 2.x will land here\n");
}
AND_CATCH(CException, e)
{
   TRACE("MFC 3.0 will land here\n");
}
END_CATCH

Esse código se comporta de forma diferente na versão 3.0 porque o controle sempre passa para o primeiro catch bloco com uma declaração de exceção correspondente. O resultado da expressão de lançamento

THROW((CException*) new CCustomException());

é lançado como um CException*, mesmo que seja construído como um CCustomException. A macro CATCH nas versões MFC 2.5 e anteriores CObject::IsKindOf usa para testar o tipo em tempo de execução. Porque a expressão

e->IsKindOf(RUNTIME_CLASS(CException));

é true, o primeiro bloco catch captura a exceção. Na versão 3.0, que usa exceções C++ para implementar muitas das macros de tratamento de exceção, o segundo bloco catch corresponde ao gerado CException.

Código como esse é incomum. Geralmente, ele aparece quando um objeto de exceção é passado para outra função que aceita um genérico CException*, executa o processamento "pré-lançamento" e, por fim, lança a exceção.

Para contornar esse problema, mova a expressão de lançamento da função para o código de chamada e gere uma exceção do tipo real conhecido para o compilador no momento em que a exceção é gerada.

Exceções de Re-Throwing

Um bloco catch não pode lançar o mesmo ponteiro de exceção que ele pegou.

Por exemplo, esse código era válido em versões anteriores, mas terá resultados inesperados com a versão 3.0:

TRY
{
   // Do something to throw an exception.
   AfxThrowUserException();
}
CATCH(CException, e)
{
   THROW(e);    // Wrong. Use THROW_LAST() instead
}
END_CATCH
   }

Usar THROW no bloco catch faz com que o ponteiro e seja excluído, de modo que o site de captura externa receba um ponteiro inválido. Use THROW_LAST para relançar e.

Para obter mais informações, consulte Exceções: Capturando e excluindo exceções.

Consulte também

Tratamento de Exceções