分享一下在C程序設計當中對異常的處理。主要是介紹一下goto和longjmp函數的使用。

在寫程序的時候，有些地方很容易出錯，當然這種出錯不是說那種你寫錯了，而是說比如硬件的初始化失敗了，或者資源暫時不可用等等導致函數返回異常。這種錯是難以避免的，而且通常是非致命的，只要多嘗試幾次可能就可以了。比如之前我們寫過網絡編程，要建立網絡通信，我們需要調用socket,bind,listen等等一系列函數，每個函數都有可能會出錯。

但是你的程序怎么知道該怎么處理呢？程序出錯了顯然是不能繼續往下執行的，但是立即終止也不合適，因為這種錯是非致命的，那么我們應該怎么去設計一個比較健壯的程序呢？今天介紹的可以當做是一種思路。

一、使用goto

說到goto，可能很多人的第一反應是不要用，但是問他為什么他可能講不出來，因為是別人告訴他的。goto真的不能用嗎？當然不是，最有力的證明就是Linux內核里面就有大量的goto語句。實際上，只要用的適當，還是非常好用的，當然我并不是說程序里面goto滿天飛。

下面舉例說明goto的應用場景：

有時候我們完成一件事情要分為很多個步驟，每個步驟里面還可能占用一些資源，然而這些步驟很容易出錯，如果其中某個步驟出錯了，就不能繼續下一個步驟，也不能立即終止程序，因為這樣會使資源得不到釋放。那么使用goto就可以調出程序并且對資源進行回收。

來看一段代碼：

#include 
#include 
char *p1=NULL,*p2=NULL,*p3=NULL;


int step1(void);
int step2(void);
int step3(void);


int main(int argc,char* argv[])
{
  if(step1()<0)
  {
    goto error1;
  }
  if(step2()<0)
  {
    goto error2;
  }
  if(step3()<0)
  {
    goto error3;
  }
error3:
  printf("釋放步驟3的資源\\n");
  free(p3);
error2:
  printf("釋放步驟2的資源\\n");
  free(p2);
error1:
  printf("釋放步驟1的資源\\n");
  free(p1);
  exit(0);
}




int step1(void)
{
  p1=(char*)malloc(10);
  return 0;
}


int step2(void)
{
  p2=(char*)malloc(10);
  return 0;
}


int step3(void)
{
  p3=(char*)malloc(10);
  return -1;
}

在這段代碼里面，假設完成一件事情一共有三個步驟，每個步驟里面都維護了一個指針變量（資源），假設步驟一和步驟二都是正常的，步驟三出了問題，返回一個錯誤的值，如果我們接收到步驟三的錯誤返回值之后立即終止程序，那么步驟一和步驟二里申請的資源就得不到釋放，比如這里的指針會造成內存泄漏，顯然不是我們希望看到的。

但是使用上面的這種結構，如果在步驟二出錯了，它會跳轉到error2這里先釋放步驟2申請的資源，再釋放步驟一 的資源，最后退出，其他的地方出錯也是類似處理。上面是一種代碼框架，實際寫代碼應該根據實際情況來處理異常。

我們來看一下效果：

以上就是goto在多個步驟容易出錯時的一種處理。這里順便提一下goto的另外一種應用場景，就是用來跳出多層循環。我們知道跳出循環一般使用break和continue，但是這個只能調出當前循環，不能跳出多層循環，有時候在多層循環里面，一旦條件滿足，我們就不需要再執行后面的循環了，使用goto可以解決這個問題。

我們來看一下代碼：

#include 


int main(void)
{
  for(int i=0;i<2;i++)
  {
    for(int j=0;j<2;j++)
    {
      for(int k=0;k<2;k++)
      {
        if(k==1)
        {
          goto lable;
        }
lable2:        printf("i=%d,j=%d,k=%d\\n",i,j,k);
      }

    }
  }
lable:
  printf("after goto \\n");
//  goto lable2;
}

在這里有三層循環嵌套，一旦條件滿足，就通過goto跳出整個循環體，執行后面的代碼。如果使用break ，就非常麻煩。

代碼的執行結果是：

第一次k=0，正常打印，第二次，k=1，滿足條件，跳出循環，執行后面的語句，打印出after goto.

當然，問題也快出來了，剛剛是上面跳到了下面，如果我們再從下面跳上去會怎么樣？我們打開最后一行的注釋，重新編譯執行，會發現打印出幾百上千行的內容：

代碼看起來好像不復雜，就是先跳下去，然后又跳回原來的后面，怎么會打印這么多東西呢？這就是使用goto不當帶來的害處。這種交叉式地跳來跳去會使得程序結構非常混亂，混亂到我也懶得去分析。

二、使用longjmp

剛剛講了goto的異常處理，但是goto有一個局限性，就是goto只能在一個函數內進行跳轉，不能跨越函數。

如果一個函數里嵌套了多個函數調用，而里層的函數出了錯，希望跳轉到上一層或上幾層的函數，該怎么辦？顯然，goto是做不到的。這時可以使用longjmp函數。longjmp函數和setjmp函數配合使用。

int setjmp(jmp_buf env);
void longjmp(jmp_buf env, int val);

先在程序容易出錯的地方使用setjmp，定義一個入口，等到后面代碼真的出錯之后使用longjmp跳轉到setjmp處。setjmp直接調用返回0，若從longjmp返回，則為非0.

舉個例子：

#include 
#include 


jmp_buf jmpbuffer;


int fun1(void);
int fun2(void);
int fun3(void);


int main(int argc,char* argv[])
{
  printf("這里是主函數\\n");
  if(setjmp(jmpbuffer)!=0)
  {
    printf("Error\\n");
  }
  fun1();          //假設fun1是一個容易出錯的函數，出錯后將返回上一步，然后再重新執行。
  printf("這里是主函數調用fun1之后\\n");
  return 0;
}


int fun1(void)
{
  printf("這里是fun1\\n");
  fun2();
}


int fun2(void)
{
  printf("這里是fun2\\n");
  fun3();
}


int fun3(void)
{
  static int i=0;
  printf("這里是fun3\\n");
  if(i++==0)
  {
    longjmp(jmpbuffer,1);   //跳轉回main函數
  }
  return -1;
}

在這里，主函數調用了fun1函數，而fun1調用fun2，fun2又調用fun3.這種多層嵌套里面，每一層都可能出錯。如果我們希望里面任何一層出錯了，就返回main函數，那么用longjmp就可以實現。對上面程序進行解釋：

當第一次執行setjmp時，由于是直接調用，所以返回0，接著調用我們的功能函數fun1，假設fun3里面出錯了，那么就會通過longjmp跳轉到setjmp處，同時攜帶一個返回值1，那么這時就會執行if語句進行錯誤處理，接著再執行fun1，也許此時就全部正常了，一直執行到最后。（這是很正常的現象，正如開頭說的，像硬件初始化，申請資源等都可能不是一次成功的，需要重復多次）。

而且在多個地方都可以使用longjmp，攜帶不同的返回值，這樣根據setjmp的返回值也很容易確定問題出在哪里。

來看一下效果：

使用longjmp還有一個問題我們可能也需要關注一下，就是當使用longjmp返回的時候，函數里的那些變量還能保持原來的值嗎？我們可以做一個實驗來驗證這一點：

#include 
#include 
#include 


static void f1(int,int,int,int);
static void f2(void);


static jmp_buf jmpbuffer;
static int global;


int main(int argc,char* argv[])
{
  int autoval;
  register int regival;
  volatile int volaval;
  static int staval;
  global=1;autoval=2;regival=3;volaval=4;staval=5;
  if(setjmp(jmpbuffer)!=0)
  {
    printf("after longjmp:\\n");
    printf("global=%d,autoval=%d,regival=%d,volaval=%d,staval=%d\\n", \\
      global,autoval,regival,volaval,staval);
    exit(0);
  }
  global=10;autoval=20;regival=30;volaval=40;staval=50;
  f1(autoval,regival,volaval,staval);
  exit(0);
}


static void f1(int a,int b,int c,int d)
{
  printf("in f1():\\n");
  printf("global=%d,autoval=%d,regival=%d,volaval=%d,staval=%d\\n", \\
    global,a,b,c,d);
  f2();
}


static void f2(void)
{
  longjmp(jmpbuffer,1);
}

這里我們定義了很多種不同的變量，先對變量賦一個初值，然后改變變量的值，接著調用f1，在f1里打印各變量的值，f1再調用f2，f2使用longjmp跳轉回main函數，那么這時各變量的值如何？是剛開始賦的初值，還是后面改變后的值呢？

我們編譯執行一下：

可以發現使用register聲明的變量保持的是初值，而其他變量都是改變后的值。

如果編譯時進行優化，結果又如何？

可以發現除了剛剛的register聲明的變量，普通局部變量（自動變量）也沒有更新，而是保持了初值，這通常不是我們希望的，我們肯定是希望得到最新的值，這也是因為編譯優化帶來的問題。所以如果希望避免這個問題，可以加上volatile來修飾。

以上就是今天要分享的內容，主要是在C程序中，由多個步驟可能引發的錯誤，或者是多層嵌套里面可能出現的錯誤進行處理，還要注意資源的回收等問題。附帶講了亂用goto帶來的弊端，以及在函數間跳轉與返回時變量的值的改變，程序優化帶來的影響等。