Exceções personalizadas C++

Excecoes Personalizadas C



Exceção em C++ é um conceito central. Uma exceção ocorre no tempo de execução quando o programa encontra inconsistências de tempo de execução ou cenários incomuns. Em C++, os termos “throw”, “try” e “catch” são usados ​​para tratar ou capturar a exceção. O comando “throw” é utilizado para gerar a exceção. O termo “try” serve para lançar a exceção, e a palavra-chave “catch” representa o tratamento de uma exceção que é desenvolvida com o termo “throw” e é lançada pela seção “try”. Vamos mergulhar em alguns exemplos para demonstrar as exceções em C++.

Exemplo 1: Programa para criar uma classe de exceção personalizada em C++

Este exemplo simples é implementado para demonstrar o tratamento e detecção de exceções customizadas em C++.

#include
#include
usando espaço para nome padrão ;

aula DemoException : público exceção
{
virtual const Caracteres * o que ( ) const lançar ( )
{
retornar 'Capturada exceção personalizada' ;
}
} ;
interno principal ( )
{
DemoException dEx ;
tentar
{
lançar dEx ;
}
pegar ( exceção & exceto )
{
corte << exceto. o que ( ) << fim ;
}
retornar 0 ;
}

Definimos o arquivo de cabeçalho no código incluindo “iostream” e “exceção”. O “iostream” é chamado especificamente para o fluxo de entrada e saída, enquanto a biblioteca “exception” é chamada para tratar a exceção. Depois disso, criamos a classe “DemoException” que é derivada da classe “exceção” de C++. Aqui, definimos a função virtual what() que é usada para fornecer o const char* que exibe os resultados de uma mensagem de erro vinculada à exceção.







Em seguida, invocamos uma função main() onde criamos o objeto “dEx” da classe “DemoException”. Depois disso, temos uma definição de bloco “try” que lança a exceção se encontrada. Aqui, lançamos o objeto “dEx”.



A seguir, definimos o bloco “catch” para capturar a exceção e tratá-la. Passamos a referência da exceção da classe como parâmetro para capturar a exceção derivada dela. Dentro do bloco “catch”, chamamos a função what() em “except” para obter a mensagem de exceção no console.



Depois de executar o programa fornecido, a mensagem de exceção personalizada é capturada e lançada no console:





Exemplo 2: Programa para criar uma exceção personalizada usando duas classes

O programa enfatiza o tratamento de múltiplas exceções que podem ser tratadas de forma independente através da definição de múltiplas classes.



#include
usando espaço para nome padrão ;

aula avaliação1 { } ;
aula avaliação2 { } ;

interno principal ( ) {
tentar {
lançar avaliação1 ( ) ;
}
pegar ( avaliação1 e ) {
corte << 'Exceção Avaliação1 capturada!' << fim ;
}
tentar {
lançar avaliação2 ( ) ;
}
pegar ( avaliação2 e ) {
corte << 'Exceção de avaliação 2 capturada!' << fim ;
}

retornar 0 ;
}

No código fornecido, temos a definição de duas classes, “Avaliação1” e “Avaliação2”, que agora estão vazias. Depois disso, executamos a função main() do programa. Aqui, definimos o bloco try{} onde a palavra-chave “throw” é usada para lançar a instância da classe “Evaluation1()”. Isso representa que a exceção “Evaluation1” será lançada se surgir alguma exceção no programa dentro deste bloco “try”. Depois disso, temos um bloco catch{} onde a exceção é capturada e exibe a mensagem da exceção.

Da mesma forma, temos uma definição de outro bloco try{} para a classe “Evaluation2”. Dentro desse bloco try{}, lançamos a instância da classe “Evaluation2”. Isso lança a exceção de “Avaliação2” se ocorrer um erro aqui. Em seguida, chamamos o bloco catch{} para exibir a mensagem de exceção usando o comando “cout” se a exceção for capturada neste bloco.

As duas exceções dos diferentes blocos “try-catch” são lançadas no console e tratadas pelas duas classes diferentes.

Exemplo 3: Programa para criar uma exceção personalizada com construtor

O programa usa o construtor para tratar a exceção. Mesmo que não possamos obter os valores do construtor, podemos conseguir isso usando o bloco “try-catch”.

#include
usando espaço para nome padrão ;

aula Teste {
interno valor ;

público :
Teste ( interno n )
{
tentar {
se ( n == 0 )
valor = n ;
mostrar ( ) ;
}

pegar ( const Caracteres * experiência ) {
corte << 'Exceção encontrada \n ' ;
corte << experiência << fim ;
}

}

vazio mostrar ( )
{
corte << 'Valor =' << valor << fim ;
}
} ;

interno principal ( )
{

Teste ( 0 ) ;
corte << 'Criando instância novamente \n ' ;
Teste ( 1 ) ;
}

No código fornecido, estabelecemos a classe “Test” onde a variável é declarada como “val” do tipo inteiro. Então, temos uma definição da função construtora “Test()” que é passada com a variável “n”. Em seguida, definimos o bloco “try-catch” dentro da função construtora “Test()”. O bloco try é chamado com a instrução if(). Se o valor de “n” for igual a zero, o bloco “catch” capturará a exceção e a mensagem de exceção será lançada no prompt. O valor de “n” é armazenado na variável “val” conforme a inicializamos.

Depois disso, chamamos a função display() para mostrar o valor que está armazenado na variável “val”. A seguir, temos a definição do bloco “catch” onde é tratada a exceção que é lançada pelo bloco “try”. Finalmente, invocamos a função main(). Dentro do qual chamamos o construtor “Test()”. O construtor é acionado quando o objeto da classe “Test()” é criado e especificado com o valor “0” no qual a exceção é lançada.

Depois disso, chamamos a classe “Test()” novamente para criar uma instância que é passada com o valor 1. Aqui, o construtor não lançará nenhuma exceção, pois o valor não é igual a 0. A função display() irá execute e imprima o valor de “val”.

A exceção personalizada é lançada no console chamando o construtor. Além disso, quando a condição é satisfeita, o construtor é executado sem nenhuma exceção.

Exemplo 4: Programa para criar uma exceção personalizada definida pelo usuário

O programa aqui trata e captura a exceção definida pelo usuário quando solicitado no prompt.

#include
#include
usando espaço para nome padrão ;
aula Minha demonstração : público exceção {
público :
const Caracteres * o que ( ) const lançar ( )
{
retornar 'Exceção! Tentei dividir por zero.! \n ' ;
}
} ;
interno principal ( )
{
tentar
{
interno n1, n2 ;
corte << 'Insira os dois números inteiros: \n ' ;
comendo >> n1 >> n2 ;
se ( n2 == 0 )
{
MinhaDemo n3 ;
lançar n3 ;
}
outro
{
corte << 'n1/n2 =' << n1 / n2 << fim ;
}
}
pegar ( exceção & ex )
{
corte << exceto. o que ( ) ;
}
}

No código fornecido, primeiro definimos a classe “MyDemo()” que é a classe dependente da exceção. Depois disso, definimos a função pública what() com a palavra-chave “virtual”. A função what() é chamada para obter a causa da exceção no programa quando a função throw() lança a exceção. Então, temos uma função main() onde os blocos try-catch{} são definidos para detectar e tratar a exceção. Dentro do bloco try{}, declaramos duas variáveis, “n1” e “n2”, cujos valores são obtidos do usuário usando o comando “cin”. Quando os valores de cada variável “n1” e “n2” forem recebidos, a condição “if” verificará se a variável “n2” é igual a 0 ou não. Nesse caso, uma exceção é lançada ou os resultados da divisão são retornados. Por último, temos um bloco catch{} que toma a referência da classe “exception” como um parâmetro herdado dela.

A saída mostra quando a condição não é atendida e o programa é executado sem exceção:

Além disso, definimos o valor “0” para a variável “n2” para representar como a exceção é lançada e capturada no programa.

Conclusão

Concluindo, demonstramos o importante conceito de C++ que é uma exceção. Uma exceção impede a execução regular do programa. Para isso, utilizamos as palavras-chave “throw”, “try” e “catch” para tratar a exceção que acontece no programa. Usamos essas palavras-chave nos exemplos anteriores para tratar a exceção de maneira diferente.