Comment lever une exception en C?

Il n'y a pas d'exceptions en C. En C, les erreurs sont notifiés par la valeur renvoyée de la fonction, la valeur de sortie du processus, des signaux aux processus (Programme des Signaux d'Erreur (GNU libc)) ou le matériel de PROCESSEUR interruption (ou autre erreur de notification forme le CPU si il y a)(Comment le processeur gère cas de division par zéro).

Exceptions, définies en C++ et en d'autres langues si. La gestion des exceptions en C++ est spécifié dans la norme C++ "S. 15 la gestion des exceptions", il n'y a pas d'article équivalent dans la norme.

Plaine vieux C n'a pas de justifier les exceptions de manière native.

Vous pouvez utiliser d'autres modes de gestion des erreurs de stratégies, telles que:

• retourne un code d'erreur
• retour FALSE et à l'aide d'un last_error variable ou une fonction.

Voir http://en.wikibooks.org/wiki/C_Programming/Error_handling.

C est capable de lancer des exceptions C++, ils sont les codes de machine de toute façon.
Par exemple, dans la barre.c

//begin bar.c
#include <stdlib.h>
#include <stdint.h>
extern void *__cxa_allocate_exception(size_t thrown_size);
extern void __cxa_throw (void *thrown_exception, void* *tinfo, void (*dest) (void *) );
extern void * _ZTIl; //typeinfo of long
int bar1()
{
   int64_t * p = (int64_t*)__cxa_allocate_exception(8);
   *p = 1976;
   __cxa_throw(p,&_ZTIl,0);
  return 10;
}
//end bar.c

dans a.cc,

#include <stdint.h>
#include <cstdio>
extern "C" int bar1();
void foo()
{
  try{
    bar1();
  }catch(int64_t x){
    printf("good %ld",x);
  }
}
int main(int argc, char *argv[])
{
  foo();
  return 0;
}

compiler

gcc -o bar.o -c bar.c && g++ a.cc bar.o && ./a.out

sortie

good 1976

http://mentorembedded.github.io/cxx-abi/abi-eh.html a de détails, plus d'infos sur __cxa_throw.

Je ne suis pas sûr que ce soit portable ou pas, et je l'ai tester avec "gcc 4.8.2' sur Linux.

Cette question est super vieux, mais je viens de tombé sur elle et j'ai pensé partager une technique: division par zéro, ou déréférencer un pointeur null.

La question est simplement de "comment jeter", et non pas comment l'attraper, ou même la façon de jeter un type spécifique d'exception. J'ai eu une situation il y a des siècles où nous en avions besoin pour déclencher une exception de C à être pris en C++. Plus précisément, nous avons eu des rapports occasionnels de "appel de fonction virtuelle pure" des erreurs, et nécessaire pour convaincre le runtime C est _purecall fonction de jeter quelque chose. Donc, nous avons ajouté nos propres _purecall fonction divisé par zéro, et boom, nous avons obtenu une exception que nous pourrions attraper sur le C++, et même utiliser certains pile amusant de voir où les choses ont mal tourné.

Comme mentionné dans un grand nombre de threads, le "standard" de la façon de le faire est d'utiliser setjmp/longjmp. J'ai posté encore une autre solution pour https://github.com/psevon/exceptions-and-raii-in-c
C'est à ma connaissance la seule solution qui s'appuie sur le nettoyage automatique des ressources allouées. Il met en œuvre unique et partagée smartpointers, et permet l'intermédiaire des fonctions de laisser des exceptions passer à travers sans attraper et ont encore leur localement les ressources allouées nettoyés correctement.

Si vous écrivez du code, avec chemin d'accès Joyeux motif de conception (c'est à dire pour des périphériques intégrés), vous pouvez simuler l'exception de traitement d'erreur (aka deffering ou enfin de l'émulation avec l'opérateur "goto".

int process(int port)
{
    int rc;
    int fd1;
    int fd2;

    fd1 = open("/dev/...", ...);
    if (fd1 == -1) {
      rc = -1;
      goto out;
    }

    fd2 = open("/dev/...", ...);
    if (fd2 == -1) {
      rc = -1;
      goto out;
    }

    //Do some with fd1 and fd2 for example write(f2, read(fd1))

    rc = 0;

   out:

    //if (rc != 0) {
        (void)close(fd1);
        (void)close(fd2);
    //}

    return rc;
}

Il ne fait pas de gestionnaire d'exception, mais il vous permet de gérer l'erreur à fucntion sortie.

P. S. Vous devez être prudent d'utiliser goto que de la même ou plus de profondeur et des étendues ne jamais sauter déclaration de variable.