void (*)() 聲明函數指針
讓我們來分析一下,左邊圓括弧中的星號是函數指針聲明的關鍵。另外兩個元素是函數的返回類型(void)和右邊圓括弧中的入口參數(本例中參數是空)。注意本例中還沒有創建指針變量-只是聲明瞭變量類型。
(void (*)())0 把0強制轉換成函數指針
(*((void (*)())0))() 調用
所以(*((void (*)())0))()的意思是:調用地址爲0處的程序。
代碼之三:
int main(int argc, char* argv[])
{
MyFun(10); //這裏是調用MyFun(10);函數
FunP=&MyFun; //將MyFun函數的地址賦給FunP變量
FunP(20); //這是通過函數指針變量來調用MyFun函數的。
return 0;
}
代碼之四:
int main(int argc, char* argv[])
{
MyFun(10); //這裏是調用MyFun(10);函數
FunP=MyFun; //將MyFun函數的地址賦給FunP變量
(*FunP)(20); //這是通過函數指針變量來調用MyFun函數的。
return 0;
}
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
http://blog.chinaunix.net/uid-25498312-id-164472.html
回調函數是一個程序員不能顯式調用的函數;通過將回調函數的地址傳給調用者從而實現調用。要實現回調,必須首先定義函數指針。儘管定義的語法有點不可思議,但如果你熟悉函數聲明的一般方法,便會發現函數指針的聲明與函數聲明非常類似。函數指針有兩具用途:調用函數和做函數的參數。請看下面的例子:
void f();// 函數原型
上面的語句聲明瞭一個函數,沒有輸入參數並返回void。那麼函數指針的聲明方法如下:
void (*) ();
讓我們來分析一下,左邊圓括弧中的星號是函數指針聲明的關鍵。另外兩個元素是函數的返回類型(void)和由邊圓括弧中的入口參數(本例中參數是空)。注意本例中還沒有創建指針變量-只是聲明瞭變量類型。目前可以用這個變量類型來創建類型定義名及用sizeof表達式獲得函數指針的大小:
// 獲得函數指針的大小
unsigned psize = sizeof (void (*) ());
// 爲函數指針聲明類型定義
typedef void (*pfv) ();
pfv是一個函數指針,它指向的函數沒有輸入參數,返回類行爲void。使用這個類型定義名可以隱藏複雜的函數指針語法
【函數指針】
在程序運行中,函數代碼是程序的算法指令部分,它們和數組一樣也佔用存儲空間,都有相應的地址。可以使用指針變量指向數組的首地址,也可以使用指針變量指向函數代碼的首地址,指向函數代碼首地址的指針變量稱爲函數指針。
1.函數指針定義
函數類型(*指針變量名)(形參列表);
“函數類型”說明函數的返回類型,由於“()”的優先級高於“*”,所以指針變量名外的括號必不可少,後面的“形參列表”表示指針變量指向的函數所帶的參數列表。
例如:
int (*f)(int x);
double (*ptr)(double x);
在定義函數指針時請注意:
函數指針和它指向的函數的參數個數和類型都應該是—致的;
函數指針的類型和函數的返回值類型也必須是一致的。
2.函數指針的賦值
函數名和數組名一樣代表了函數代碼的首地址,因此在賦值時,直接將函數指針指向函數名就行了。
例如,
int func(int x); /* 聲明一個函數 */
int (*f) (int x); /* 聲明一個函數指針 */
f=func; /* 將func函數的首地址賦給指針f */
賦值時函數func不帶括號,也不帶參數,由於func代表函數的首地址,因此經過賦值以後,指針f就指向函數func(x)的代碼的首地址。
3.通過函數指針調用函數
函數指針是通過函數名及有關參數進行調用的。
與其他指針變量相類似,如果指針變量pi是指向某整型變量i的指針,則*p等於它所指的變量i;如果pf是指向某浮點型變量f的指針,則*pf就等價於它所指的變量f。同樣地,*f是指向函數func(x)的指針,則*f就代表它所指向的函數func。所以在執行了f=func;之後,(*f)和func代表同一函數。
由於函數指針指向存儲區中的某個函數,因此可以通過函數指針調用相應的函數。現在我們就討論如何用函數指針調用函數,它應執行下面三步:
首先,要說明函數指針變量。
例如:int (*f)(int x);
其次,要對函數指針變量賦值。
例如: f=func; (func(x)必須先要有定義)
最後,要用 (*指針變量)(參數表);調用函數。
例如: (*f)(x);(x必須先賦值)
【例】任意輸入n個數,找出其中最大數,並且輸出最大數值。
main()
{
int f();
int i,a,b;
int (*p)(); /* 定義函數指針 */
scanf('%d',&a);
p=f; /* 給函數指針p賦值,使它指向函數f */
for(i=1;i<9;i++)
{
scanf('%d',&b);
a=(*p)(a,b); /* 通過指針p調用函數f */
}
printf('The Max Number is:%d',a)
}
f(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
運行結果爲:
343 -45 4389 4235 1 -534 988 555 789↙
The Max Number is:4389
【例】(*((void (*)())0))() 表示什麼意思?
void (*)() 聲明函數指針
讓我們來分析一下,左邊圓括弧中的星號是函數指針聲明的關鍵。另外兩個元素是函數的返回類型(void)和右邊圓括弧中的入口參數(本例中參數是空)。注意本例中還沒有創建指針變量-只是聲明瞭變量類型。
(void (*)())0 把0強制轉換成函數指針
(*((void (*)())0))() 調用
所以(*((void (*)())0))()的意思是:調用地址爲0處的程序。
【指針函數】
一個函數不僅可以帶回一個整型數據的值,字符類型值和實型類型的值,還可以帶回指針類型的數據,使其指向某個地址單元。
返回指針的函數,一般定義格式爲:
類型標識符 *函數名(參數表)
int *f(x,y);
其中x,y是形式參數,f是函數名,調用後返回一個指向整型數據的地址指針。f(x,y)是函數,其值是指針。
如:char *ch();表示的就是一個返回字符型指針的函數,請看下面的例題:
【例】將字符串1(str1)複製到字符串2(str2),並輸出字符串2.
#include 'stdio.h'
main()
{
char *ch(char *,char *);
char str1[]='I am glad to meet you!';
char str2[]='Welcom to study C!';
printf('%s',ch(str1,str2));
}
char *ch(char *str1,char *str2)
{
int i;
char *p;
p=str2
if(*str2==NULL) exit(-1);
do
{
*str2=*str1;
str1++;
str2++;
}while(*str1!=NULL);
return(p);
}
通過分析可得
函數指針是一個指向函數的指針,而指針函數只是說明他是一個返回值爲指針的函數,函數指針可以用來指向一個函數。
函數名與函數指針
一通常的函數調用
一個通常的函數調用的例子:
//自行包含頭文件
void MyFun(int x); //此處的申明也可寫成:void MyFun( int );
int main(int argc, char* argv[])
{
MyFun(10); //這裏是調用MyFun(10);函數
return 0;
}
void MyFun(int x) //這裏定義一個MyFun函數
{
printf(“%d\n”,x);
}
這個MyFun函數是一個無返回值的函數,它並不完成什麼事情。這種調用函數的格式你應該是很熟悉的吧!看主函數中調用MyFun函數的書寫格式:
MyFun(10);
我們一開始只是從功能上或者說從數學意義上理解MyFun這個函數,知道MyFun函數名代表的是一個功能(或是說一段代碼)。
二函數指針變量的申明
就象某一數據變量的內存地址可以存儲在相應的指針變量中一樣,函數的首地址也以存儲在某個函數指針變量裏的。這樣,我就可以通過這個函數指針變量來調用所指向的函數了。
在C系列語言中,任何一個變量,總是要先申明,之後才能使用的。那麼,函數指針變量也應該要先申明吧?那又是如何來申明呢?以上面的例子爲例,我來申明一個可以指向MyFun函數的函數指針變量FunP。下面就是申明FunP變量的方法:
void (*FunP)(int) ; //也可寫成void (*FunP)(int x);
你看,整個函數指針變量的申明格式如同函數MyFun的申明處一樣,只不過——我們把MyFun改成(*FunP)而已,這樣就有了一個能指向MyFun函數的指針FunP了。(當然,這個FunP指針變量也可以指向所有其它具有相同參數及返回值的函數了。)
三通過函數指針變量調用函數
有了FunP指針變量後,我們就可以對它賦值指向MyFun,然後通過FunP來調用MyFun函數了。看我如何通過FunP指針變量來調用MyFun函數的:
//自行包含頭文件
void MyFun(int x); //這個申明也可寫成:void MyFun( int );
void (*FunP)(int ); //也可申明成void(*FunP)(int x),但習慣上一般不這樣。
int main(int argc, char* argv[])
{
MyFun(10); //這是直接調用MyFun函數
FunP=&MyFun; //將MyFun函數的地址賦給FunP變量
(*FunP)(20); //這是通過函數指針變量FunP來調用MyFun函數的。
}
void MyFun(int x) //這裏定義一個MyFun函數
{
printf(“%d\n”,x);
}
哦,我的感覺是:MyFun與FunP的類型關係類似於int 與int *的關係。函數MyFun好像是一個如int的變量(或常量),而FunP則像一個如int *一樣的指針變量。
int i,*pi;
pi=&i; //與FunP=&MyFun比較。
四調用函數的其它書寫格式
函數指針也可如下使用,來完成同樣的事情:
//自行包含頭文件
void MyFun(int x);
void (*FunP)(int ); //申明一個用以指向同樣參數,返回值函數的指針變量。
int main(int argc, char* argv[])
{
MyFun(10); //這裏是調用MyFun(10);函數
FunP=MyFun; //將MyFun函數的地址賦給FunP變量
FunP(20); //這是通過函數指針變量來調用MyFun函數的。
return 0;
}
void MyFun(int x) //這裏定義一個MyFun函數
{
printf(“%d\n”,x);
}
FunP=MyFun;
可以這樣將MyFun值同賦值給FunP,難道MyFun與FunP是同一數據類型(即如同的int 與int的關係),而不是如同int 與int*的關係了?(有沒有一點點的糊塗了?)
看來與之前的代碼有點矛盾了,是吧!所以我說嘛!
請容許我暫不給你解釋,繼續看以下幾種情況(這些可都是可以正確運行的代碼喲!):
代碼之三:
int main(int argc, char* argv[])
{
MyFun(10); //這裏是調用MyFun(10);函數
FunP=&MyFun; //將MyFun函數的地址賦給FunP變量
FunP(20); //這是通過函數指針變量來調用MyFun函數的。
return 0;
}
代碼之四:
int main(int argc, char* argv[])
{
MyFun(10); //這裏是調用MyFun(10);函數
FunP=MyFun; //將MyFun函數的地址賦給FunP變量
(*FunP)(20); //這是通過函數指針變量來調用MyFun函數的。
return 0;
}
真的是可以這樣的噢!
還有吶!看——
int main(int argc, char* argv[])
{
(*MyFun)(10); //看,函數名MyFun也可以有這樣的調用格式
return 0;
}
呵呵!假使我是“福爾摩斯”,依據以往的知識和經驗來推理本篇的“新發現”,必定會由此分析並推斷出以下的結論:
1. 其實,MyFun的函數名與FunP函數指針都是一樣的,即都是函數指針。MyFun函數名是一個函數指針常量,而FunP是一個函數數指針變量,這是它們的關係。
2. 但函數名調用如果都得如(*MyFun)(10);這樣,那書寫與讀起來都是不方便和不習慣的。所以C語言的設計者們纔會設計成又可允許MyFun(10);這種形式地調用(這樣方便多了並與數學中的函數形式一樣,不是嗎?)。
3. 爲統一起見,FunP函數指針變量也可以FunP(10)的形式來調用。
4. 賦值時,即可FunP=&MyFun形式,也可FunP=MyFun。
上述代碼的寫法,隨便你愛怎麼着!
補充說明一點:在函數的申明處:
void MyFun(int ); //不能寫成void (*MyFun)(int )。
void (*FunP)(int ); //不能寫成void FunP(int )。
五定義某一函數的指針類型:
就像自定義數據類型一樣,我們也可以先定義一個函數指針類型,然後再用這個類型來申明函數指針變量。
我先給你一個自定義數據類型的例子。
typedef int* PINT; //爲int* 類型定義了一個PINT的別名
int main()
{
int x;
PINT px=&x; //與int * px=&x;是等價的。PINT類型其實就是int * 類型
*px=10; //px就是int*類型的變量
return 0;
}
下面我們來看一下函數指針類型的定義及使用:(請與上對照!)
//自行包含頭文件
void MyFun(int x); //此處的申明也可寫成:void MyFun( int );
typedef void (*FunType)(int ); //這樣只是定義一個函數指針類型
FunType FunP; //然後用FunType類型來申明全局FunP變量
int main(int argc, char* argv[])
{
//FunType FunP; //函數指針變量當然也是可以是局部的,那就請在這裏申明瞭。
MyFun(10);
FunP=&MyFun;
(*FunP)(20);
return 0;
}
void MyFun(int x)
{
printf(“%d\n”,x);
}
看黑體部分:
首先,在void (*FunType)(int ); 前加了一個typedef 。這樣只是定義一個名爲FunType函數指針類型,而不是一個FunType變量。
然後,FunType FunP; 這句就如PINT px;一樣地申明一個FunP變量。
其它相同。整個程序完成了相同的事。
這樣做法的好處是:
有了FunType類型後,我們就可以同樣地、很方便地用FunType類型來申明多個同類型的函數指針變量了。如下:
FunType FunP2; FunType FunP3;
六函數指針作爲某個函數的參數
既然函數指針變量是一個變量,當然也可以作爲某個函數的參數來使用的。所以,你還應知道函數指針是如何作爲某個函數的參數來傳遞使用的。
給你一個實例:
要求:我要設計一個CallMyFun函數,這個函數可以通過參數中的函數指針值不同來分別調用MyFun1、MyFun2、MyFun3這三個函數(注:這三個函數的定義格式應相同)。
實現:代碼如下:
//自行包含頭文件
void MyFun1(int x);
void MyFun2(int x);
void MyFun3(int x);
typedef void (*FunType)(int ); //②. 定義一個函數指針類型FunType,與①函數類型一至
void CallMyFun(FunType fp,int x);
int main(int argc, char* argv[])
{
CallMyFun(MyFun1,10); //⑤. 通過CallMyFun函數分別調用三個不同的函數
CallMyFun(MyFun2,20);
CallMyFun(MyFun3,30);
}
void CallMyFun(FunType fp,int x) //③. 參數fp的類型是FunType。
{
fp(x);//④. 通過fp的指針執行傳遞進來的函數,注意fp所指的函數是有一個參數的
}
void MyFun1(int x) // ①. 這是個有一個參數的函數,以下兩個函數也相同
{
printf(“函數MyFun1中輸出:%d\n”,x);
}
void MyFun2(int x)
{
printf(“函數MyFun2中輸出:%d\n”,x);
}
void MyFun3(int x)
{
printf(“函數MyFun3中輸出:%d\n”,x);
}
分析:(看我寫的註釋。你可按我註釋的①②③④⑤順序自行分析。)