linux c 实现try catch异常捕获

最新推荐文章于 2023-09-16 02:33:45 发布
最新推荐文章于 2023-09-16 02:33:45 发布
阅读量3.8k 收藏 6
点赞数

前言：

像如java这样的面相对象语言，异常处理机制让其代码更具健壮性，可以代码捕获到如算术异常，空指针异常等，俘获并能够在预知情况下进行相应处理。那么对于C而言，是否能实现其功能？

简要分析：

Linux有对线程或者进程退出时有一种信号量机制，而默认情况下，这种signal是系统自己处理的，而最统一的处理方式是exit，而至于什么原因退出这个完全取决于什么样的信号。至于linux下的这些signal多少，哪个对应什么情况自行查阅资料。Linux_c 的实现将通过宏来实现。

直接粗暴上代码吧：

 exception.h

#ifndef EXCEPTION_H_
#define EXCEPTION_H_

#include <setjmp.h>
#include <signal.h>

/* MANPROCSIGnals. */
#define MANPROCSIG_HUP  1 /* Hangup (POSIX). */
#define MANPROCSIG_INT  2 /* Interrupt (ANSI). */
#define MANPROCSIG_QUIT  3 /* Quit (POSIX). */
#define MANPROCSIG_ILL  4 /* Illegal instruction (ANSI). */
#define MANPROCSIG_TRAP  5 /* Trace trap (POSIX). */
#define MANPROCSIG_ABRT  6 /* Abort (ANSI). */
#define MANPROCSIG_IOT  6 /* IOT trap (4.2 BSD). */
#define MANPROCSIG_BUS  7 /* BUS error (4.2 BSD). */
#define MANPROCSIG_FPE  8 /* Floating-point exception (ANSI). */
#define MANPROCSIG_KILL  9 /* Kill, unblockable (POSIX). */
#define MANPROCSIG_USR1  10 /* User-defined MANPROCSIG_nal 1 (POSIX). */
#define MANPROCSIG_SEGV  11 /* Segmentation violation (ANSI). */
#define MANPROCSIG_USR2  12 /* User-defined MANPROCSIG_nal 2 (POSIX). */
#define MANPROCSIG_PIPE  13 /* Broken pipe (POSIX). */
#define MANPROCSIG_ALRM  14 /* Alarm clock (POSIX). */
#define MANPROCSIG_TERM  15 /* Termination (ANSI). */
#define MANPROCSIG_STKFLT 16 /* Stack fault. */
#define MANPROCSIG_CLD  MANPROCSIG_CHLD /* Same as MANPROCSIG_CHLD (System V). */
#define MANPROCSIG_CHLD  17 /* Child status has changed (POSIX). */
#define MANPROCSIG_CONT  18 /* Continue (POSIX). */
#define MANPROCSIG_STOP  19 /* Stop, unblockable (POSIX). */
#define MANPROCSIG_TSTP  20 /* Keyboard stop (POSIX). */
#define MANPROCSIG_TTIN  21 /* Background read from tty (POSIX). */
#define MANPROCSIG_TTOU  22 /* Background write to tty (POSIX). */
#define MANPROCSIG_URG  23 /* Urgent condition on socket (4.2 BSD). */
#define MANPROCSIG_XCPU  24 /* CPU limit exceeded (4.2 BSD). */
#define MANPROCSIG_XFSZ  25 /* File size limit exceeded (4.2 BSD). */
#define MANPROCSIG_VTALRM 26 /* Virtual alarm clock (4.2 BSD). */
#define MANPROCSIG_PROF  27 /* Profiling alarm clock (4.2 BSD). */
#define MANPROCSIG_WINCH 28 /* Window size change (4.3 BSD, Sun). */
#define MANPROCSIG_POLL  MANPROCSIG_IO /* Pollable event occurred (System V). */
#define MANPROCSIG_IO  29 /* I/O now possible (4.2 BSD). */
#define MANPROCSIG_PWR  30 /* Power failure restart (System V). */
#define MANPROCSIG_SYS  31 /* Bad system call. */
#define MANPROCSIG_UNUSED 31

#define T Exception_t
typedef struct Exception_t{
	char *reason;
}Exception_t;

typedef struct Exception_frame{
	struct Exception_frame *prev;
	jmp_buf env;
	const char *file;
	int line;
	const T* exception;
}Exception_frame;

extern Exception_frame *Exception_stack;

enum{
	EXCEPTION_ENTERED=0,
	EXCEPTION_RAISED,
	EXCEPTION_HANDLED,
	EXCEPTION_FINALIZED
};

/* Manage all process signal,and automanage signal by process cause exit directoryly,*/
#define ManProcAllSig \
    int sum = 31; \
   while(sum){ \
    signal(sum,handle_proc_sig); \
    sum--; \
}

/*Throw a exception*/
#define throw(e) exception_raise(&(e),__FILE__,__LINE__)

#define rethrow exception_raise(exception_frame.exception, \
          exception_frame.file,exception_frame.line)

void handle_proc_sig(int signo);

void abort_without_exception(const Exception_t *e,const char *file,int line);

void exception_raise(const T *e,const char *file,int line);

#define try do{ \
    volatile int exception_flag; \
    Exception_frame exception_frame; \
    exception_frame.prev = Exception_stack; \
    Exception_stack = &exception_frame; \
    ManProcAllSig \
    exception_flag = setjmp(exception_frame.env); \
    if (exception_flag == EXCEPTION_ENTERED) \
    {

#define catch(e) \
  if(exception_flag == EXCEPTION_ENTERED) \
   Exception_stack = Exception_stack->prev; \
  }else if(exception_flag == e){ \
   exception_flag = EXCEPTION_HANDLED;

#define try_return \
   switch(Exception_stack = Exception_stack->prev,0) \
    default: return

#define catch_else \
   if(exception_flag == EXCEPTION_ENTERED) \
    Exception_stack = Exception_stack->prev; \
    }else if(exception_flag != EXCEPTION_HANDLED){ \
     exception_flag = EXCEPTION_HANDLED;

#define end_try \
    if(exception_flag == EXCEPTION_ENTERED) \
     Exception_stack = Exception_stack->prev; \
     } \
     if (exception_flag == EXCEPTION_RAISED) \
      exception_raise(exception_frame.exception, \
        exception_frame.file,exception_frame.line); \
    }while(0)

#define finally \
    if(exception_flag == EXCEPTION_ENTERED) \
     Exception_stack = Exception_stack->prev; \
    }{ \
     if(exception_flag == EXCEPTION_ENTERED) \
       exception_flag = EXCEPTION_FINALIZED;

#undef T
#endif /* EXCEPTION_H_ */


exception.c

#include "exception.h"
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>


Exception_frame *Exception_stack = NULL;


void exception_raise(const Exception_t *e,const char *file,int line)
{
	Exception_frame *p = Exception_stack;

	assert(e);

	if(p == NULL)
	{
		abort_without_exception(e,file,line);
	}

	p->exception = e;
	p->file = file;
	p->line = line;
	Exception_stack = Exception_stack->prev;
	longjmp(p->env,EXCEPTION_RAISED);
}


void abort_without_exception(const Exception_t *e,const char *file,int line)
{
	//fprintf(stderr,"Uncaught exception");

	if(e->reason)
	{
		fprintf(stderr," %s",e->reason);
	}
	else
	{
		fprintf(stderr,"at 0x%p",e);
	}
		
	if(file && line > 0)
	{
		fprintf(stderr, "raised at %s:%d\n",file,line);
	}
	fprintf(stderr,"aborting...\n");
	fflush(stderr);
	abort();
}


void handle_proc_sig(int signo)
{
	if( signo == MANPROCSIG_HUP )
		printf(" Hangup (POSIX). \r\n");
	else if( signo == MANPROCSIG_INT )
		printf(" Interrupt (ANSI). \r\n");
	else if( signo == MANPROCSIG_QUIT )
		printf(" Quit (POSIX). \r\n");
	else if( signo == MANPROCSIG_ILL )
		printf(" Illegal instruction (ANSI). \r\n");
	else if( signo == MANPROCSIG_TRAP )
		printf(" Trace trap (POSIX). \r\n");
	else if( signo == MANPROCSIG_ABRT )
		printf(" Abort (ANSI). \r\n");
	else if( signo == MANPROCSIG_IOT )
		printf(" IOT trap (4.2 BSD). \r\n");
	else if( signo == MANPROCSIG_BUS )
		printf(" BUS error (4.2 BSD). \r\n");
	else if( signo == MANPROCSIG_FPE )
		printf(" Floating-point exception (ANSI). \r\n");
	else if( signo == MANPROCSIG_KILL )
		printf(" Kill, unblockable (POSIX). \r\n");
	else if( signo == MANPROCSIG_USR1 )
		printf(" User-defined signal if( signo == (POSIX). \r\n");
	else if( signo == MANPROCSIG_SEGV )
		printf(" Segmentation violation (ANSI). \r\n");
	else if( signo == MANPROCSIG_USR2 )
		printf(" User-defined signal 2 (POSIX). \r\n");
	else if( signo == MANPROCSIG_PIPE )
		printf(" Broken pipe (POSIX). \r\n");
	else if( signo == MANPROCSIG_ALRM )
		printf(" Alarm clock (POSIX). \r\n");
	else if( signo == MANPROCSIG_TERM )
		printf(" Termination (ANSI). \r\n");
	else if( signo == MANPROCSIG_STKFLT )
		printf(" Stack fault. \r\n");
	else if( signo == MANPROCSIG_CLD )
		printf(" Same as SIGCHLD (System V). \r\n");
	else if( signo == MANPROCSIG_CHLD )
		printf(" Child status has changed (POSIX). \r\n");
	else if( signo == MANPROCSIG_CONT )
		printf(" Continue (POSIX). \r\n");
	else if( signo == MANPROCSIG_STOP )
		printf(" Stop, unblockable (POSIX). \r\n");
	else if( signo == MANPROCSIG_TSTP )
		printf(" Keyboard stop (POSIX). \r\n");
	else if( signo == MANPROCSIG_TTIN )
		printf(" Background read from tty (POSIX). \r\n");
	else if( signo == MANPROCSIG_TTOU )
		printf(" Background write to tty (POSIX). \r\n");
	else if( signo == MANPROCSIG_URG )
		printf(" Urgent condition on socket (4.2 BSD). \r\n");
	else if( signo == MANPROCSIG_XCPU )
		printf(" CPU limit exceeded (4.2 BSD). \r\n");
	else if( signo == MANPROCSIG_XFSZ )
		printf(" File size limit exceeded (4.2 BSD). \r\n");
	else if( signo == MANPROCSIG_VTALRM )
		printf(" Virtual alarm clock (4.2 BSD). \r\n");
	else if( signo == MANPROCSIG_PROF )
		printf(" Profiling alarm clock (4.2 BSD). \r\n");
	else if( signo == MANPROCSIG_WINCH )
		printf(" Window size change (4.3 BSD, Sun). \r\n");
	else if( signo == MANPROCSIG_POLL )
		printf(" Pollable event occurred (System V). \r\n");
	else if( signo == MANPROCSIG_IO )
		printf(" I/O now possible (4.2 BSD). \r\n");
	else if( signo == MANPROCSIG_PWR )
		printf(" Power failure restart (System V). \r\n");
	else if( signo == MANPROCSIG_SYS)
		printf(" Bad system call. \r\n");
	else if( signo == MANPROCSIG_UNUSED)
		printf(" Unknow erroe. \r\n");

	Exception_frame *p = Exception_stack;
	Exception_stack = Exception_stack->prev;
	longjmp(p->env,signo);

	// exit(0);
	//exit process
}


测试：test.c

#include <stdio.h>
#include "exception.h"

void test()
{
	char *a=NULL;
	*a=1;
}

int main()
{
	try
	{
		test();			//SimulateNULLpointerexception!!
	}
	catch(MANPROCSIG_SEGV)	//Catchtheexception
	{
		printf("NULLpointer!!\r\n");
	}
	catch_else
	{
		printf("UnknowError!!\r\n");
	}
	finally
	{
		printf("DONE\r\n");
	}
	end_try;

	return 0;
}

 

 

whatday
关注
使用__try...__except或try...catch捕获异常防止C++程序产生异常崩溃（附源码）
dvlinker的技术专栏
07-28 4412
使用__try...__except或try...catch捕获异常防止C++程序产生异常崩溃（附源码）
linux c语言错误处理
03-15
linux 常见的错误处理，c语言编程中的细节注意之处。
Linux_C实现try catch异常捕获
ZeroOneMonk
03-29 5850
前言：像如java这样的面相对象语言，异常处理机制让其代码更具健壮性，可以代码捕获到如算术异常，空指针异常等，俘获并能够在预知情况下进行相应处理。那么对于C而言，是否能实现其功能？简要分析：Linux有对线程或者进程退出时有一种信号量机制，而默认情况下，这种signal是系统自己处理的，而最统一的处理方式是exit，而至于什么原因退出这个完全取决于什么样的信号。至于linux下的这些signal多...
Linux C try/catch
weixin_43155199的博客
11-23 3304
创作人QQ：851301776，邮箱：[lfr890207@163.com](mailto:lfr890207@163.com)，欢迎大家一起技术交流，本博客主要是自己学习的心得体会,只为每天进步一点点！ 个人座右铭： 1.没有横空出世，只要厚积一定发。 2.你可以学历不高，你可以不上学，但你不能不学习。 一、try/catch原理 ​ try/catch，是一种代码中跳转的思想。主要分为四个点：try、catch/throw、finaliy。核心是：setjmp和longjmp，与我...
linux c 异常实现,linux c 实现try catch异常捕获
weixin_30583711的博客
05-16 668
前言：像如java这样的面相对象语言，异常处理机制让其代码更具健壮性，可以代码捕获到如算术异常，空指针异常等，俘获并能够在预知情况下进行相应处理。那么对于C而言，是否能实现其功能？简要分析：Linux有对线程或者进程退出时有一种信号量机制，而默认情况下，这种signal是系统自己处理的，而最统一的处理方式是exit，而至于什么原因退出这个完全取决于什么样的信号。至于linux下的这些signal多...
多此一举， C实现 try-catch
weixin_33994429的博客
05-26 437
在做NtyTcp的时候，有一些，就想用c来实现一套try-catch异常处理子系统。不讨论C语言本身为什么不加try-catch，每个开发的朋友对于这个问题，都能说出一大堆的理由。其实我也是不太喜欢强行在c中加入一个try-catch。就像把try-catch的原理跟自己的体会写出来。首先我们来看看，try-catch的使用情景。try{ throwExcep;...
65- 异常及异常捕获(try/catch)
记录java学习日常~
09-16 211
Java 异常是在程序运行期间发生的非正常情况，例如输入错误、网络故障等，这些异常会导致程序运行出现问题或停止运行。在 Java 中，异常是以类的形式存在的，它们都继承自 Throwable 类。在这个异常体系结构中，Error 表示系统级别的错误，一般由 JVM 抛出，程序无法处理。例如：OutOfMemoryError、StackOverflowError 等。Exception 是可检查的异常的父类，表示程序运行时发生的异常情况。它有许多子类和继承层次，其中包括 RuntimeException。
C++的Try Catch异常捕获笔记和应用示例
快乐编程——D6Plan
06-02 801
C++异常处理捕获笔记和应用示例1.什么是异常捕获？2.为什么要捕获异常？3.使用异常捕获3.1基础语法3.2使用示例总结附加:函数的异常声明列表 1.什么是异常捕获？ 在C++中，一个函数能够检测出异常并且将异常返回，这种机制称为抛出异常。当抛出异常后，函数调用者捕获到该异常，并对该异常进行处理，我们称之为异常捕获。 2.为什么要捕获异常？ 大多数时候我们需要编写的程序能够在异常的情况下也能作出相应的处理，而异常捕获可以帮助在任何自己得到不想要的结果的时候进行中断并给予反馈。 3.使用异常捕获 3.1基础
linux try catch捕获异常信息
最新发布
09-28
在 Linux 环境下，我们通常使用 shell 脚本编程来捕获异常信息。在 shell 脚本中，我们可以使用 `trap` 命令来捕获异常并执行相应的处理操作。下面是一个示例： ```bash #!/bin/bash # 捕获异常信号并执行处理函数...
paip 提升用户体验---gcc c++ try catch不能捕获异常的解决--使用 SEH Ca6
jffyuhgv的博客
02-18 482
paip 提升用户体验---gcc c++ try catch不能捕获异常的解决--使用 SEH Ca6
C语言异常封装 模仿try catch
10-22
C语言异常封装 模仿try catch 源码可以运行,C语言是JAVA的鼻祖
C语言 非本地跳转 实现native层TryCatch
baiiu
04-19 505
C语言的本地跳转是指goto、break、continue等语句，但是这个语句最大局限就是只能实现函数内部的跳转。C 语言提供了一种用户级异常控制流形式，称为非本地跳转（non local jump），它将控制直接从一个函数转移到另一个当前正在执行的函数，而不需要经过正常的调用—返回序列。
Recording_linux c++下 try catch用法
haihan5937的博客
10-02 1335
#include #include"iostream" using namespace std; int main() { try{         if(1)throw"get 1"; } catch(const char*msg) { cout } return 0; }
linux 下 C 编程和make的方法 （十、C版的try catch 捕捉段错误和异常处理）
robertzhouxh的专栏
07-10 1980
哇塞，C语言有try catch吗？当然没有。倒。。可能有人说了，那你野鬼说没有的东西做什么。      这里需要重申一下，所谓正向设计下问题检测的开发方法。正向设计时，在错误检测和问题修复的方法是指：       根据源码分析，在源码中加插检测代码的方式，验证对代码的理解和预判是否正确。      而反向跟踪是根据机器执行动作，反向理解逻辑的运行状态，例如GDB。两者很多方面都很像，但存
linux c 异常捕获,如何在Linux C ++中捕获系统级异常？
weixin_31613423的博客
05-16 184
请检查 http://linux.die.net/man/1/gcc中有一个编译器选项-mcheck-zero-division来处理。另外，也可以选择安装SIGFPE处理程序，然后将float div乘以0将生成一个’FPE_ZERODIVIDE’signal(SIGFPE, (fptr) FPE_ExceptionHandler);void FPE_ExceptionHandler(int n...
linux c 析构catch不到异常,c – 如果我知道我的函数不会抛出异常,我应该在析构函数中放置try … catch块...
weixin_31293841的博客
05-16 130
我知道析构函数不应该抛出异常.我有以下代码：~a(){cleanup();}// I do not expect exception being thrown in this function.// If exception really happen, I know that it is something not recoverable.void a::cleaup(){delete p;}在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值