Tratamento de exceções em MFC

Este artigo explica os mecanismos de tratamento de exceções disponíveis no MFC. Dois mecanismos estão disponíveis:

• Exceções do C++, disponível no MFC versão 3.0 e posterior

• Macros de exceção do MFC, disponíveis nas versões do MFC 1.0 e posterior

Se você estiver escrevendo um novo aplicativo usando o MFC, deverá usar o mecanismo C++. Você pode usar o mecanismo baseado em macro se seu aplicativo existente já usar esse mecanismo extensivamente.

Você pode converter prontamente o código existente para usar exceções C++ em vez das macros de exceção MFC. As vantagens de converter seu código e as diretrizes para fazer isso estão descritas no artigo Exceções: convertendo de Macros de Exceção do MFC.

Se você já desenvolveu um aplicativo usando as macros de exceção do MFC, poderá continuar usando essas macros em seu código existente enquanto usa exceções C++ no seu novo código. O artigo Exceções: alterações nas macros de exceção na Versão 3.0 fornece diretrizes para isso.

Este artigo aborda os seguintes tópicos:

• Quando usar exceções

• Suporte a exceções do MFC

• Leitura adicional sobre exceções

Quando usar exceções

Três categorias de resultados podem ocorrer quando uma função é chamada durante a execução do programa: execução normal, execução errônea ou execução anormal. Cada categoria está descrita abaixo.

• Execução normal

  A função pode ser executada normalmente e retornar. Algumas funções retornam um código de resultado ao chamador, o que indica o resultado da função. Os códigos de resultado possíveis são estritamente definidos para a função e representam o intervalo de possíveis resultados da função. O código de resultado pode indicar êxito ou falha, ou pode até mesmo indicar um tipo específico de falha que está dentro do intervalo normal de expectativas. Por exemplo, uma função de status de arquivo pode retornar um código que indica que o arquivo não existe. Observe que o termo "código de erro" não é usado, porque um código de resultado representa um dos muitos resultados esperados.

• Execução errônea

  O chamador comete algum erro ao passar argumentos para a função ou chama a função em um contexto inadequado. Essa situação causa um erro, e deve ser detectada por uma instrução assert durante o desenvolvimento do programa. (Para obter mais informações sobre instruções assert, consulte Instruções assert do C/C++.)

• Execução anormal

  A execução anormal inclui situações em que condições fora do controle do programa, como memória baixa ou erros de E/S, estão influenciando o resultado da função. Situações anormais devem ser tratadas capturando e lançando exceções.

O uso de exceções é especialmente adequado em execuções anormais.

Suporte a exceções do MFC

Seja usando as exceções do C++ diretamente ou usando as macros de exceção do MFC, você usará a Classe CException ou objetos derivados de CException que podem ser gerados pela estrutura ou pelo seu aplicativo.

A tabela a seguir mostra as exceções predefinidas fornecidas pelo MFC.

A partir da versão 3.0, o MFC usa as exceções do C++, mas ainda dá suporte a macros de tratamento de exceções antigas, que têm formato semelhante ao das exceções do C++. Embora essas macros não sejam recomendadas para novos programas, ainda há suporte a elas para garantir a compatibilidade com versões anteriores. Em programas que já usam as macros, você também pode usar livremente as exceções do C++. Durante o pré-processamento, as macros são avaliadas como as palavras-chave de tratamento de exceções definidas na implementação MSVC da linguagem C++ a partir da versão 2.0 do Visual C++. Você pode manter as macros de exceção existentes em vigor quando você começar a usar exceções do C++. Para obter informações sobre como combinar macros e o tratamento de exceções C++ e sobre como converter código antigo para usar o novo mecanismo, consulte os artigos Exceções: usar macros do MFC e exceções C++ e Exceções: converter a partir de macros de exceção do MFC. As macros de exceção mais antigas do MFC, se você ainda as usa, são avaliadas para palavras-chave de exceção C++. Consulte Exceções: alterações nas macros de exceção na versão 3.0. O MFC não dá suporte diretamente aos manipuladores de exceção estruturados (SEH) do Windows NT, conforme discutido no Tratamento de exceções estruturadas.

Leitura adicional sobre exceções

Os artigos a seguir explicam como usar a biblioteca MFC para entrega de exceção:

• Exceções: obtendo e excluindo exceções

• Exceções: examinando o conteúdo da exceção

• Exceções: liberando objetos em exceções

• Exceções: lançando exceções das suas próprias funções

• Exceções: exceções de banco de dados

• Exceções: exceções OLE

Os artigos a seguir comparam as macros de exceção do MFC com as palavras-chave de exceção C++ e explicam como você pode adaptar seu código:

• Exceções: alterações feitas em macros de exceção na versão 3.0

• Exceções: convertendo de macros de exceção do MFC

• Exceções: usando macros MFC e exceções C++

Confira também

Práticas recomendadas do C++ modernas para tratamento de erros e exceções