C e Java

yetlinux
(usa Ubuntu)

Enviado em 24/04/2009 - 08:36h

Olá.

Existe algum recurso em C ou C++ semelhante ao try...catch do Java?

Desde já agradeço.

wizard.slack
(usa Slackware)

Enviado em 24/04/2009 - 08:43h

sim existe
A forma de uso deles é a seguinte:



try {

// código a ser tentado

throw excecao;

}

catch (tipo excessao)

{

// código a ser executado em caso de exceção

}

yetlinux
(usa Ubuntu)

Enviado em 24/04/2009 - 09:07h

Mas ambos C e C++ possuem o recurso?

mslomp
(usa Slackware)

Enviado em 24/04/2009 - 10:24h

para o caso do C, a resposta é sim e não. explico:
em c++, try, catch, throw, finally são macros construídas com o uso de setjmp e longjmp, ambas funções ansi c. então, embora c não traga nativamente essa 'feature', ela pode ser construída com o simples uso das duas funções citadas.
a saber: setjmp salva o ponteiro de instrução (eip em um x86-32) e os estados dos registradores naquele momento. então você "tenta o código" (try). caso haja uma exceção, longjmp restaura os valores guardados por setjmp. sendo assim, a execução retornará ao ponto onde foi salvo anteriormente e então "tentará outra abordagem" (catch), tratando a exceção.

andrezc
(usa Debian)

Enviado em 24/04/2009 - 20:04h

C e Java a mistura perfeita :)

stremer
(usa Arch Linux)

Enviado em 25/04/2009 - 01:20h

nossa ... explicação EXCELENTE!

Agora só um complemento.
Existem alguns funções que se utiliza em C que o tratamento de excessão já é feito dentro delas e portanto não se consegue utilizar este tipo de tratamento... é preciso analisar o código de erro que geralmente é o retorno da função e ai sim disparar uma exceção sua, caso queira adotar um padrão para o tratamento de erros.

yetlinux
(usa Ubuntu)

Enviado em 28/04/2009 - 09:02h

Alguém tem um exemplo de código destas funções em C?

mslomp
(usa Slackware)

Enviado em 28/04/2009 - 21:28h

segue um exemplo básico, onde o objetivo é apenas dividir um número por outro, este fornecido como argumento. coloquei os números das linhas para facilitar o entendimento:

01 #include <stdio.h>
02 #include <setjmp.h>
03
04 /* exceções */
05 #define DIV_BY_ZERO 1 /* divisão por zero */
06 #define NO_ARG_SPEC 2 /* nenhum argumento especificado */
07
08 int
09 main(int argc, char** argv) {
10 jmp_buf jmp;
11 switch(setjmp(jmp)){
12 case 0:
13 if(argc>1) {
14 int i = atoi(argv[1]);
15 if(i==0)
16 longjmp(jmp,DIV_BY_ZERO );
17 int x = 10 / i;
18 printf("Resultado: %d\n",x);
19 }
20 else {
21 longjmp(jmp,NO_ARG_SPEC);
22 }
23 break;
24 case DIV_BY_ZERO:
25 printf("Argumento invalido... divisao por zero!\n");
26 break;
27 case NO_ARG_SPEC:
28 printf("Argumento nao especificado!\n");
29 break;
30 }
31 return 0;
32 }

traduzindo em miúdos: digamos que você defina duas exceções: divisão por zero e falta de argumento (linhas 05 e 06). o programa começa definindo uma variável do tipo jmp_buf (10), que armazena o índice do contexto a ser salvo por setjmp. na linha 11, setjmp irá salvar o contexto e será avaliado por switch. como jmp é zero na primeira avaliação, cairemos no caso 0 (12). supondo que algum argumento (numérico) tenha sido passado ao programa, avaliaremos se o valor é zero (15). caso afirmativo, teríamos na linha 17 uma divisão por zero, o que não queremos. iremos então 'disparar uma exceção' (DIV_BY_ZERO) através de longjmp, que fará com que o contexto retorne ao local salvo anteriormente (linha 11), tendo jmp como o valor correspondente à exceção. switch então irá saltar para o caso DIV_BY_ZERO. supondo que nenhum argumento tenha sido passado, o que foi avaliado em 13, iremos à linha 21 onde, seguindo o mesmo raciocínio, dispararemos a exceção NO_ARG_SPEC.

agora podemos juntar tudo isso e construir as macros try, throw e catch e aplicá-los no exemplo acima:

#include <stdio.h>
#include <setjmp.h>

#define try jmp_buf jmp; switch(setjmp(jmp)){case 0:
#define throw(e) longjmp(jmp,e)
#define catch(e) break;case e:

/* exceções */
#define DIV_BY_ZERO 1 /* divisão por zero */
#define NO_ARG_SPEC 2 /* nenhum argumento especificado */

int
main(int argc, char** argv) {
try {
if(argc>1) {
int i = atoi(argv[1]);
if(i==0)
throw(DIV_BY_ZERO);
int x = 10 / i;
printf("Resultado: %d\n",x);
}
else
throw(NO_ARG_SPEC);
}
catch(DIV_BY_ZERO) {
printf("Argumento invalido... divisao por zero!\n");
}
catch(NO_ARG_SPEC) {
printf("Argumento nao especificado!\n");
}
}
return 0;
}

yetlinux
(usa Ubuntu)

Enviado em 23/05/2009 - 12:00h

Excelente! Deveria ir para a seção de scripts.

Esses comandos funcionam como os desvios incondicionais da programação espaguete?

mslomp
(usa Slackware)

Enviado em 23/05/2009 - 13:00h

na ocasião adicionei uma implementação simples na seção scripts, incluindo a referência ao tópico:
http://www.vivaolinux.com.br/script/Excecoes-em-C-atraves-de-trythrowcatch