Exemplo 1:
O “iostream” é o arquivo de cabeçalho incluído aqui que colocamos para que possamos utilizar os métodos “cin” ou “cout” em nosso código, já que ambos os métodos são declarados dentro dele. O objeto “cerr” também é declarado neste arquivo de cabeçalho. Então, temos o “namespace std”. Agora, não precisamos adicionar este “std” com cada função de forma independente.
Então, “main()” é invocado aqui. Abaixo disso, utilizamos o objeto “cerr” e colocamos a mensagem de erro que queremos exibir no console. Digitamos “Ocorreu um erro aqui!” mensagem neste “cerr” após colocar os símbolos de inserção. Ao executarmos este programa, a mensagem fornecida é exibida sem o uso do “cout”.
Código 1:
#includeusando namespace std ;
interno principal ( ) {
cerr << 'Ocorreu um erro aqui!' << fim ;
retornar 0 ;
}
Saída:
A mensagem que digitamos após colocar “cerr <<” agora é exibida neste resultado que é exibido a seguir:
Exemplo 2:
Como os métodos “cin” e “cout”, bem como “cerr” são declarados dentro do arquivo de cabeçalho “iostream”, adicionamos o arquivo de cabeçalho aqui para que possamos usá-los em nosso código. Depois disso, temos o “namespace std”. Abaixo disso, o “main()” é então chamado. Inicializamos “error_str[]” do tipo de dados “string” e atribuímos uma mensagem a “error_str[]”. Em seguida, utilizamos o objeto “cerr” onde colocamos a mensagem de erro e passamos este “error_str”. Então, quando executamos este programa, ele renderiza ambas as mensagens.
Código 2:
#includeusando namespace std ;
interno principal ( ) {
Caracteres erro_str [ ] = 'Não podemos ler a string aqui!' ;
cerr << 'Ocorreu um erro:' << erro_str << fim ;
}
Saída:
O texto que digitamos após digitar “cerr <<” agora fica visível no resultado assim como a mensagem que adicionamos em “error_str”. O resultado também é mostrado a seguir:
Exemplo 3:
Após incluir o arquivo de cabeçalho e colocar o namespace “std”, chamamos o método “main()”. Depois disso, a variável inteira “NumOfLine” é declarada aqui e inicializada com “__LINE__”. Este “__LINE__” gera as mensagens de erro. Abaixo dele, utilizamos o objeto “cerr” e colocamos a mensagem de erro que queremos exibir ao usuário. Colocamos também a variável “NumOfLine” que mostra o número da linha em que ocorre o erro no código.
Código 3:
#includeusando namespace std ;
interno principal ( ) {
interno NumOfLine = __LINHA__ ;
cerr << 'Ocorreu um erro aqui na linha:' << NumOfLine ;
retornar 0 ;
}
Saída:
Aqui, mostra que o erro ocorre na linha “4” quando adicionamos “__LINE__” na quarta linha do código. Esta mensagem é exibida aqui com a ajuda do objeto “cerr” em C++.
Exemplo 4:
Incluímos mais um arquivo de cabeçalho, o “fstream”. Este arquivo de cabeçalho “fstream” é utilizado em C++ para ler, escrever ou criar um arquivo, pois é a combinação de “ofstream” e também de “ifstream”. Agora, após adicionar “std namespace” e invocar “main()”, utilizamos o “fstream” com a variável “new_file”.
Então, usamos a função “open()” aqui com o “new_file” e passamos o nome do arquivo como parâmetro. O nome do arquivo é “myTextFile.txt” que queremos abrir. Abaixo disso, utilizamos “if” para passar a variável “new_file”. Agora, se o arquivo abrir aqui, a instrução após “if” será renderizada. Caso contrário, a instrução após “else” é renderizada onde adicionamos o objeto “cerr” para mostrar uma mensagem de erro.
Código 4:
#include#include
usando namespace std ;
interno principal ( ) {
fstream novo_arquivo ;
novo arquivo. abrir ( 'meuArquivoTexto.txt' ) ;
se ( novo arquivo ) {
corte << 'O arquivo foi aberto com sucesso aqui!' ;
}
outro {
cerr << 'Ocorreu um erro aqui ao abrir o arquivo aqui!' ;
}
retornar 0 ;
}
Saída:
Não podemos abrir o arquivo que fornecemos anteriormente. Aqui ele exibe a mensagem de erro que inserimos após o objeto “cerr”.
Exemplo 5:
Aqui, queremos abrir outro arquivo. Portanto, adicionamos os arquivos de cabeçalho e o namespace “std”. Agora, chamamos “main()” e então utilizamos “fstream” com a variável “t_file”. A seguir, utilizamos a função “open()” neste caso com “new_file” e fornecemos o nome do arquivo como argumento. O arquivo que desejamos abrir chama-se “New.txt”. Usamos a instrução “if”, passando a variável “t_file”. Agora, se o arquivo for aberto, a linha que segue “if” será renderizada. Caso contrário, a instrução que segue “else”, onde adicionamos o objeto “cerr” para exibir uma mensagem de erro, é renderizada.
Código 5:
#include#include
usando namespace std ;
interno principal ( ) {
fstream t_file ;
arquivo_t. abrir ( 'Novo.txt' ) ;
se ( arquivo_t ) {
corte << 'O arquivo é aberto aqui!' ;
}
outro {
cerr << 'Erro ocorrido!' ;
}
retornar 0 ;
}
Saída:
O arquivo que fornecemos não pode ser aberto. Portanto, a mensagem de erro que adicionamos após o objeto “cerr” é exibida a seguir:
Exemplo 6:
Adicionamos aqui um arquivo de cabeçalho de “exceção” que é utilizado para verificar erros que podem ocorrer em nosso código. A seguir, inicializamos um array do tipo inteiro denominado “new_array” de tamanho “6”. Em seguida, definimos o “new_index” da variável “int” e atribuímos “7” aqui. Agora, também inicializamos a variável “new_size” e atribuímos “*(&new_arr + 1) – new_arr” à variável “new_size”.
Depois disso, utilizamos “try”, “throw” e “catch” que são usados para verificar os erros e lançar a mensagem de erro. Utilizamos o objeto “color” que mostra a mensagem de erro que adicionamos após a palavra-chave “throw”.
Código 6:
#include#include
usando namespace std ;
interno principal ( ) {
interno novo_arr [ 6 ] = { 1 , 9 , 4 , 3 , 8 , 7 } ;
interno novo_índice = 7 ;
interno novo_tamanho = * ( & novo_arr + 1 ) - novo_arr ;
tentar {
se ( novo_índice < 0 || novo_índice >= novo_tamanho ) lançar ( 'O índice não está no intervalo. Está fora do intervalo aqui' ) ;
outro
corte << novo_arr [ novo_índice ] ;
}
pegar ( const Caracteres * errar ) {
cerr << errar ;
}
retornar 0 ;
}
Saída:
Aqui, ele exibe uma mensagem de erro que mostra que o “Índice” está fora do intervalo e obtemos esse erro ao utilizar o objeto “cerr”.
Exemplo 7:
Aqui verificamos um erro que pode ocorrer quando dividimos um número por zero. Criamos uma função “d()” na qual passamos duas variáveis de tipo de dados “int” “a1” e “a2”. Abaixo disso, adicionamos “if” no qual passamos a condição “a2==0”. Se o valor de “a2” for zero, é executada a mensagem que colocamos após o “throw” que obtemos colocando o objeto “cerr” no código.
Após isso, colocamos o “return” que retorna a resposta da divisão se o valor de “a2” não for zero. Agora, invocamos “main()” e atribuímos “87” a “x” após inicializá-lo como uma variável “int”. Depois disso, inicializamos também as variáveis “b” e “d_res” com “0”. Aqui, colocamos o “try” e o “catch” que capturam o erro e o “cerr” lança a mensagem de erro que adicionamos após a palavra-chave “throw”.
Código 7:
#includeusando namespace std ;
interno minha_divisão ( interno a1 , interno a2 ) {
se ( a2 == 0 ) {
lançar 'A divisão por zero não é possível!' ;
}
retornar ( a1 / a2 ) ;
}
interno principal ( ) {
interno x = 87 ;
interno e = 0 ;
interno d_nada = 0 ;
tentar {
d_nada = minha_divisão ( x , e ) ;
corte << d_nada << fim ;
} pegar ( const Caracteres * mensagem ) {
cerr << mensagem << fim ;
}
retornar 0 ;
}
Saída:
Aqui aparece a mensagem de erro que significa que queremos dividir o número por “0”, o que é impossível.
Conclusão
O objeto “cerr” é estudado em detalhes aqui. Definimos como o objeto “cerr” auxilia na exibição da mensagem de erro na programação C++. Exploramos vários exemplos onde colocamos muitas condições onde o erro ocorre. Também utilizamos o objeto “cerr” após colocar o método try-catch e no código de abertura do arquivo. Mostramos o código e também o resultado em que o “cerr” exibe uma mensagem de erro.