1.Nginx和Redis中兩種回調函數寫法

#include <stdio.h>//仿Nginx風格
//結構外聲明函數指針類型
typedef void (*ngx_connection_handler_pt)(int c);
//仿redis風格
typedef void redisCommandProc(int c);
typedef struct
{
int a;
//結構內定義函數指針變量pshow
void (*pshow)(int);
//結構內定義函數指針變量
ngx_connection_handler_pt   handler;
redisCommandProc *proc;
}TMP;void func(TMP *tmp)
{tmp->handler(tmp->a);tmp->proc(tmp->a);if(tmp->a >10)//如果a>10,則執行回調函數。{tmp->pshow(tmp->a);}
}void show(int a)
{printf("a的值是%d\n",a);
}void main()
{TMP test;test.a = 11;test.pshow = show;test.handler = show;test.proc = show;func(&test);
}

函數名就是一個指針，如同于數組a[]，a和&a其實都是一樣的。當調用一個函數時，我們都是直接用函數名調用，或者說通過指針調用。

風格1--tpyedef自定義函數指針類型

#include <stdio.h>
typedef int (*fp_t)(char c);int f0(char c) { 
printf("f0, c = %c\n", c); 
return 0;
}int f1(char c) { 
printf("f1, c = %c\n", c); 
return 1;
}int main(){int ret;fp_t fp;//fp是一個指向一個函數類型（返回的是int，參數是char）的函數指針fp = f0;ret = fp('a');通過函數指針調用函數fp = f1;ret = fp('x');return 0;
}

風格2--typedef自定義函數類型

#include <stdio.h>
typedef int f_t(char c);int f0(char c) { 
printf("f0, c = %c\n", c); 
return 0;
}int f1(char c) { 
printf("f1, c = %c\n", c); 
return 1;
}int main()
{int ret;f_t *fp;//f_t是函數類型，所以fp是指向此函數類型的指針fp = f0;ret = fp('a');fp = f1;ret = fp('x');//函數指針調用此函數return 0;
}

《C語言程序設計：現代方法：第2版》

2.函數指針定義

函數指針及應用
我們先來看一下以下 的聲明:
int f(int);
int? (*pf)(int)=&f;//&操作符可選;因為函數名被使用時總是由編譯器把它轉換為函數指針;

或者

pf=f;
int ans;
ans=f(25);
ans=(*pf)(25);
ans=pf(25);//間接訪問操作并非必需,因為編譯器需要的是一個函數指針;

使用舉例：

#include <stdio.h> ?
int getA(int a)
{
return a+1;
}int getB(int b)
{
return b*2;
}int search(void const * a,void const * b,int(*compare)(void const *,void const *))
{
return compare(a,b);
}
int copmare_int(void const *a,void const *b)
{
if(*(int *)a==*(int *)b)
{
return 0;
}
else{
return 1;
}
}int (*pf)(int k);
int main(void) ?
{ ?
int f=0;
printf( "please input>>>\n");
scanf("%d",&f);
if(f==1)
{
pf=getA;
}
else{
pf=getB;
}
int ff=pf(f);
printf( "ff =%d\n", ff);int f1=0;
int f2=0;
int x1=2;
int x2=2;
f1=search(&x1,&x2,copmare_int);
printf( "f1 =%d\n", f1);
} 

3.函數指針應用一--回調函數

這里有一個簡單的函數,它用于在一個單鏈表中查找一個值,它的參數是一個指向鏈表第一個節點的指針以及那個需要查找的值.

Node* search_list(Node* node,int const value){ while(node!=NULL){ if(node->value==value)break;node=node->link;}return node;}

這個函數看上去相當簡單,但它只適用于值為整數的鏈表,如果你需要在一個字符串鏈表中查找,你不得不另外編寫一個函數,這個函數和上面那個函數的絕大部分代碼相同,只是第二個參數的類型以及節點值的比較方法不同.

一種更為通用的方法是查找函數與類型無關,這樣它就能用于任何類型的值的鏈表,我們必須對函數的兩個方面進行修改,使它與類型無關.首先我們必須改變比較的執行方式,這樣函數就可以對任何類型的值進行比較.這個目標聽上去好象不可能,如果你編寫語句用于比較整型值,它怎么還可能用于其他類型如字符串的比較呢?解決方案就是使用函數指針,調用者編寫一個函數,用于比較兩個值,然后把一個指向這個函數的指針作為參數傳遞給查找函數.然后查找函數調用這個函數來執行值的比較,使用這種方法,任何類型的值都可以進行比較.我們必須修改的第二個方面是向函數傳遞一個指向值的指針而不是本身.函數由一個void *形參,用于接收這個參數,然后指向這個值的指針便傳遞給比較函數,這個修改使字符串和數組對象也可以被使用,字符串和數組無法作為參數傳遞給函數,但指向它們的指針可以.

使用這種技巧的函數叫"回調函數"(callback function);因為用戶把一個函數指針作為參數傳遞給其他函數,后者將"回調"用戶的函數.任何時候,如果你所編寫的

函數必須能夠在不同的時刻執行不同類型的工作或執行只能由函數調用者定義的工作,你都可以使用這個技巧.許多窗口系統使用回調函數連接多個動作,如拖拽鼠標和點擊按鈕來指定用戶程序中的某個特定函數.我們無法在這個上下文環境中為回調函數編寫一個準確的原型,因為我們并不知道進行比較的值的類型.事實上,我們需要查找函數能作用于任何類型的值,解決這個難題的方法是把參數類型聲明為"void *",表示"一個指向未知類型的指針".

/***在一個單鏈表中查找一個指定值的函數,它的參數是一個指向鏈表第一個節點**的指針,一個指向我們需要查找的值的指針和一個函數指針,它所指向的函數**用于比較存儲于此鏈表中的類型的值.*/#include<stdio.h>#include "node.h"Node* search_list(Node *node,void const *value,int(*compare)(void const*,void const*)) //函數聲明;{ while (node!=NULL){ if(compare(&node->value,value)==0) break;node=node->link;}return node;}

同時注意雖然函數不會修改參數node所指向的任何節點,但node并未聲明為const。如果node被聲明為const,函數不得不返回一個const結果，這將限制調用程序，它便無法修改查找函數所找到的節點。

在一個特定的鏈表中進行查找時，用戶需要編寫一個適當的比較函數，并把指向該函數的指針和指向需要查找的值的指針傳遞給查找函數。例如，下面是一個比較函數，它用于在一個整數鏈表中進行查找。

int compare_ints(void const* a,void const* b){if(*(int*)a==*(int*)b) return 0;else return 1;}

這個函數將像下面這樣使用：

desired_node=search_list(root,&desired_value,compare_ints);

4.函數指針應用二--轉移表（jump table)

轉移表最好用個例子來解釋。下面的代碼段取自一個程序，它用于實現一個袖珍式計算器。程序的其他部分已經讀入兩個數（op1和op2）和一個操作符（oper)。下面的代碼對操作符進行測試，最后決定調用哪個函數。

switch(oper) {case ADD: result=add(op1,op2);break;case SUB: result=sub(op1,op2);break;case MUL: result=mul(op1,op2);break;case DIV: result=div(op1,op2);break;}

對于一個新奇的具有上百個操作符的計算器，這條switch語句將會非常之長。

為什么要調用函數來執行這些操作呢？把具體操作和選擇操作的代碼分開是一種良好的設計方案。更為復雜的操作將肯定以獨立的函數來實現，因為它們的長度可能很長。但即使是簡單的操作也可能具有副作用，例如保存一個常量值用于以后的操作。

為了使用switch語句，表示操作符的代碼必須是整數。如果它們是從零開始連續的整數，我們可以使用轉換表來實現相同的任務。轉換表就是一個函數指針

數組。

創建一個轉換表需要兩個步驟。首先，聲明并初始化一個函數指針數組。唯一

需要留心之處就是確保這些函數的原型出現在這個數組的聲明之前。

double add(double,double);

double sub(double,double);

double mul(double,double);

double div(double,double);

……

double (*oper_func[])(double,double)={

add,sub,mul,div,

……}；

初始化列表中各個函數名的正確順序取決于程序中用于表示每個操作符的整型代碼。這個例子假定ADD是0，SUB是1，MUL是2，接下去以此類推。

第二個步驟是用下面這條語句替換前面整條switch語句！

result=oper_func[oper](op1,op2);

oper從數組中選擇正確的函數指針，而函數調用操作符將執行這個函數。

5.復雜的函數指針拆解

void (*signal (int signo,void (*func) (int) )) (int)

這一大堆看起來很難，其實仔細分析下不算很難搞。

首先要明白一件事：這里都是從最基本的語法展開的。

那么這里最基本的語法就是函數的聲明：返回值 函數名（參數）。
先將這一大堆給看成void (f)(int)也就是將*signal (int signo,void (*func) (int) )看成f，那么相對而言就比較好理解了。
那么signal就是函數名，而他的返回值為指向函數f的指針即（指向一個返回值為void參數為int的函數的指針）。
然后signal的參數為signo和一個返回值為void參數為int的函數指針。
然后那個f的返回值為void 參數為int這就不必多說了。

好了，關于void (*signal (int signo,void (*func) (int) )) (int)這個字面上的意思大抵就是這樣。

其實是unix信號通信機制里面的。具體如下：
void (*signal(int signo, void (*func)(int)))(int);
typedef void Sigfunc(int);

Sigfunc *signal(int, Sigfunc *);

從這里結合上面的分析我們可以得出singal這個函數的返回值類型為void(*)(int)。

同時
#define??? SIG_ERR??????? (void (*)(int))-1
#define??? SIG_DFL??????? (void (*)(int))0
#define??? SIG_IGN??????? (void (*)(int))1

這里以(void(*)())1表示將1強制性轉換為返回值為void參數為int的函數指針。
不知道干嘛要這樣，后來看到一個demo后明白了。
if (signal(SIGINT, sig_int) == SIG_ERR)這里用來捕捉各個信號。
由于signal的返回值類型為void(*)(int)所以為了區別各個信號所以只能將這些東西定義為這么復雜的聲明了。

關于typedef參考： 深度分析typedef

總結

以上是生活随笔為你收集整理的函数指针--Nginx和Redis中两种回调函数写法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。