函數指針

本質上是一個指針，只不過指向函數而已。

編譯器在編譯期間對函數開辟了一塊空間，而這快空間的開始地址，就是它的函數指針 。

下面我們也直接用最直觀的程序來了解函數指針：

#if 1
void func()
{
	printf("hello ptr!");
}
int main()
{
	void (*p)();
	p = func;
	p();
}
#endif

在這里我們給出了func()函數，并在其中打印hello ptr! 。在這里，我們定義了一個函數指針p，大家會發現他的定義語句十分的奇特： void (*p)() ,其實與int a,float b……十分的類似，定義嘛，實際上也就是給出類型，給出變量名，在這里void (*p)() 給出的類型是指向返回值為void 無參數傳入的函數 ,在這里我們把這個指針命名為p。

這條程序中，我們直接將與p類型相對應的函數func()的地址func賦值給p，于是我們便能拿著p去做func的事情了。

換言之，如果我們需要定義一個指向返回值為double，有一個int型參數a，一個long型參數b，名稱為f_ptr的函數指針呢？

那么顯然便是： double (*f_ptr)(int a,long b)

但其實因為我們只需要告訴編譯器我們的函數指針指向的是一個什么類型的函數，所以參數名并不是必須的只需告訴他是什么類型即可，所以我們還可以簡寫為 double (*f_ptr)(int , long)

我們還要注意到一個小細節：

標準規定：函數名，可以認為是其開始地址

所以函數指針p獲取函數地址： p = &Max; == p = Max;

函數指針p怎么調用： (*p)(10,20); == p(10,20);

我們同樣能夠拿上述程序來做個實驗：

函數指針的應用

函數指針在我們程序中最常見的應用其實應該是作為函數的參數。比如，我們可以這樣：

int Add(int a, int b)  //加法實現
{
	return a + b;
}
int Sub(int a, int b)  //減法實現
{
	return a - b;
}
int Mul(int a, int b)  //乘法實現
{
	return a * b;
}
int Div(int a, int b)  //除法實現
{
	if (b == 0)
		return -1;
	return a / b;
}
int Computer(int a, int b, int(*p)(int, int))   //模板函數
{
	return p(a, b);
}
int main()
{
	printf("a+b=%d\n", Computer(10, 20, Add));
	printf("a-b=%d\n", Computer(10, 20, Sub));
	printf("a*b=%d\n", Computer(10, 20, Mul));
	printf("a/b=%d\n", Computer(10, 20, Div));
	return 0;
}

在這里，我們做出了一個模板函數computer，在他的參數列表中，我們給出了int (*p)(int,int)的參數，我們調用函數的時候需要給到這個函數一個函數指針，而我們也在模板函數中使用了函數指針來調用具體函數。

我們定義了Add、Sub、Mul、Div四個具體的實現函數，用來實現相應的加減乘除，而computer只需要接受具體的函數指針來決定他需要干什么，這樣為程序的可拓展性提供了非常大的幫助，我們不需要在想要增刪功能的時候修改主要代碼，僅需增刪具體的功能函數就行，甚至部分庫函數利用函數指針作為參數的優點來為我們提供可自定義的功能，下面也用一個例子來解釋。

函數指針作為參數實例（qsort函數）

qsort函數包含在<stdlib.h>庫中

qsort函數的原型描述為：

void qsort( void *base, size_t n_elements, size_t el_sizeint ,int (*compar) (void const * , void const * ) )

qsort函數其實是C語言為我們編寫好的一個快速排序函數，他通過函數指針為我們開放了一定的自定義功能

各參數解析，base中傳入需要排序的數組，n_elements為該數組中元素的個數，el_sizeint為數組各元素的大小，而compar，則是我們今天反復提及的函數指針，在這里可以理解成為數組內各元素的比較規則。

干說可能很難理解，直接上程序：

int compare_int(const void* a,const void* b)  //用于比較兩個整型值的具體函數
{
	//將函數傳入的參數進行強轉
	int _a = *(const int*)a;
	int _b = *(const int*)b;
	//不相等
	if (_a > _b)
		return 1;
	else if (_a < _b)
		return -1;
	//相等
	else
		return 0;
}
int main()
{
	int arr[] = { 1,3,5,7,2,4,6,7,10,9,8 };
	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), compare_int);
	for (int i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
		printf("%d ", arr[i]);
	return 0;
}

此程序中，我們定義了自己的比較規則compare_int函數，傳入到qsort函數的最后一個參數，其余參數正常傳入，排序成功！

(qsort函數的比較規則默認返回1則第一個參數大于第二個參數，返回-1則反之，返回0則傳入的兩個參數相等)

在這里強轉是必須的，因為默認傳入的是兩個const void*類型，這在程序中是無法進行比較的。

同時，參數的類型也必須都寫為const void* 因為在qsort函數聲明中明確表示傳入的函數指針應為返回值為int，兩個參數都為const void*類型，自定義比較規則函數的參數類型若不為const void*則會造成函數類型不匹配的問題。

我們在這里也不妨想想一個字符串的指針數組應該如何寫出我們的自定義函數來排序呢？

int compare_string(const void* _str1, const void* _str2)
{
	//強轉類型
	const char* str1 = *(const char**)_str1;
	const char* str2 = *(const char**)_str2;
	//利用string.h庫中stramp函數（返回值契合qsort函數比較規則）來進行比較
	int tem = strcmp(str1, str2);
	return tem;
}
int main()
{
	const char* arr[] = { "abc","dsa","adfw","odc","adsfa","afsd" };
	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(const char*), compare_string);
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]);i++)
		printf("%s ", arr[i]);
	return 0;
}

可能在這大家疑惑的地方在于為什么需要使用一個二級指針來進行強轉，其實在這里可以用我們平時的指針參數傳入來理解，比如void func(int* a)，我們傳入給這個帶*參數時實際上傳入的是a的地址。

同理我們傳入_str的是什么？我們原數組是一個指針數組，每個元素本質上是個一級指針，那么我們每次比較時傳入給compare_string函數一個帶*的參數，是不是那便是一級指針的地址，即二級指針，加上一個解引用的*變回一級指針便可以賦給str1了。

總結

本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關注服務器之家的更多內容!

原文鏈接：https://blog.csdn.net/ivanii/article/details/121500741