C語言指針與qsort函數(shù)怎么使用

本篇內(nèi)容主要講解“C語言指針與qsort函數(shù)怎么使用”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“C語言指針與qsort函數(shù)怎么使用”吧!

前言

指針數(shù)組是一個存儲指針的數(shù)組，數(shù)組指針是一個指向函數(shù)的指針，數(shù)組參數(shù)和指針參數(shù)。其中不乏有很多需要注意的知識點，例如：&數(shù)組名和數(shù)組名表示的含義，一二維數(shù)組的傳參，一二維指針的傳參。

函數(shù)指針

數(shù)組指針：指向數(shù)組的指針就是數(shù)組指針。

函數(shù)指針：指向函數(shù)的指針就是函數(shù)指針。

int arr[5] = { 0 };
int(*p1)[5] = &arr;

p1就是數(shù)組指針，&數(shù)組名—取出的數(shù)組的地址。

那么&函數(shù)名—取出的就是函數(shù)的地址。

int Add(int x, int y)
{
	return x + y;
}
#include<stdio.h>
int main()
{
	printf("%p\n", &Add);
	printf("%p\n", Add);
	return 0;
}

對于函數(shù)來，&函數(shù)名和函數(shù)名都是函數(shù)的地址。

函數(shù)只要定義了，就有地址，此時函數(shù)放在代碼區(qū)（只能讀，不能改）。

int Add(int x, int y)
{
	return x + y;
}
#include<stdio.h>
int main()
{
	int (*pf)(int, int) = &Add;//int (*pf)(int x,int y) = Add
	int ret = pf(2, 3);//(*pf(2,3)//這里的*可以寫也可以不寫
	//因為Add是函數(shù)的地址，而pf存放的是Add的地址，一般調(diào)用Add函數(shù)都是Add(x,y),故*可以寫也可以不寫
	//*僅表示pf是指針，并不是解引用
	printf("%d\n", ret);
	printf("%p\n", &Add);
	printf("%p\n", Add);
	return 0;
}

void test()
{
 printf("hehe\n");
}
//下面pfun1和pfun2哪個有能力存放test函數(shù)的地址？
void (*pfun1)();
void *pfun2();

首先，能給存儲地址，就要求pfun1或者pfun2是指針，那哪個是指針？

答案是：

pfun1可以存放。pfun1先和*結(jié)合，說明pfun1是指針，指針指向的是一個函數(shù)，指向的函數(shù)無參數(shù)，返回值類型為void。

當函數(shù)作為形參傳參時，函數(shù)指針作為形參來接受。

例子：

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
void calc(int (*p)(int, int))
{
	int a = 3;
	int b = 4;
	int ret = p(a, b);
	printf("%d\n", ret);
}
int main()
{
	calc(Add);
	return 0;
}

代碼一

(*(void (*)())0)();

0由int 類型強制類型轉(zhuǎn)換成函數(shù)指針類型void(*)(),(void(*)())0是函數(shù)的地址。

以上代碼是一次函數(shù)調(diào)用，調(diào)用的是0作為地址處大的函數(shù)。

• 把0強制類型轉(zhuǎn)換成：無參數(shù)，返回類型是void的函數(shù)地址。

• 調(diào)用0地址處的這個函數(shù)，沒有參數(shù)，返回值的類型是void。

代碼二

void (*signal(int , void(*)(int)))(int);

據(jù)分析知，signal是函數(shù)名，void(*)(int)是函數(shù)的指針類型

以上代碼是一個函數(shù)聲明，聲明的signal函數(shù)的第一個參數(shù)的類型是int,第二個參數(shù)的類型是函數(shù)指針，該函數(shù)指針指向的函數(shù)參數(shù)是int，返回類型是void,返回類型是void;signal函數(shù)的返回類型也是一個函數(shù)指針，該函數(shù)指針指向的函數(shù)參數(shù)是int，返回類型是void。

簡化：

typedef void(*pf_t)(int);//把void(*)(int)類型重命名為pf_t
pf_t signal(int, pf_t);

int Add(int ,int );//函數(shù)聲明

函數(shù)指針數(shù)組

數(shù)組是一個存放相同類型數(shù)據(jù)的存儲空間，已經(jīng)學習了指針數(shù)組，例如：

int* arr[10];
//數(shù)組的每個元素是int*

那要把函數(shù)的地址存到一個數(shù)組中，那這個數(shù)組就叫函數(shù)指針數(shù)組，函數(shù)指針的數(shù)組定義:

int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];

答案是：parr1

parr1 先和 [] 結(jié)合，說明 parr1是數(shù)組，數(shù)組的內(nèi)容是 int (*)() 類型的函數(shù)指針。

函數(shù)指針數(shù)組的用途

函數(shù)指針數(shù)組的用途是轉(zhuǎn)移表。

寫一個計算器：加法，減法，乘法，除法

計算器的基本代碼

#include<stdio.h>
void menu()
{
	printf("**************************\n");
	printf("***    1.Add  2.Sub    ***\n");
	printf("***    3.Mul  4.Div    ***\n");
	printf("***       0.exit       ***\n");
	printf("**************************\n");
}
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("請選擇算法:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("請輸入兩個操作數(shù):>");
			scanf("%d %d", &x, &y);
			ret = Add(x, y);
			printf("%d\n", ret);
			break;
		case 2:
			printf("請輸入兩個操作數(shù):>");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("%d\n", ret);
			break;
		case 3:
			printf("請輸入兩個操作數(shù):>");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("%d\n", ret);
			break;
		case 4:
			printf("請輸入兩個操作數(shù):>");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			printf("%d\n", ret);
			break;
		case 0:
			printf("退出計算器\n");
			break;
		default:
			printf("選擇錯誤\n");
			break;
		}
	} while (input);
	return 0;
}

以上為計算機的一個基本代碼，但是代碼重復性太高，那么可以通過用函數(shù)作為參數(shù)傳參，用函數(shù)指針來作為形參來接受。

函數(shù)指針實現(xiàn)簡單的計算機

#include<stdio.h>
void menu()
{
	printf("**************************\n");
	printf("***    1.Add  2.Sub    ***\n");
	printf("***    3.Mul  4.Div    ***\n");
	printf("***       0.exit       ***\n");
	printf("**************************\n");
}
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
void calc(int (*pf)(int, int))
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("請輸入兩個操作數(shù):>");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("%d\n", ret);
}
int main()
{
	int input = 0;
	do
	{
		menu();
		printf("請選擇算法:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(Add);
			break;
		case 2:
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
			break;
		case 0:
			printf("退出計算器\n");
			break;
		default:
			printf("選擇錯誤\n");
			break;
		}
	} while (input);
	return 0;
}

函數(shù)指針數(shù)組實現(xiàn)簡單計算機

竟然函數(shù)指針能實現(xiàn)，那么通過修改后，函數(shù)指針數(shù)組也能實現(xiàn)。

#include<stdio.h>
void menu()
{
	printf("**************************\n");
	printf("***    1.Add  2.Sub    ***\n");
	printf("***    3.Mul  4.Div    ***\n");
	printf("***       0.exit       ***\n");
	printf("**************************\n");
}
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int (*pf)(int, int) = Add;
	//函數(shù)指針數(shù)組
	//轉(zhuǎn)移表
	int (*arr[5])(int, int) = { 0,Add,Sub,Mul,Div };
	do
	{
		menu();
	    printf("請選擇算法:>");
		scanf("%d", &input);
		if (input >= 1 && input <= 4)
		{
			printf("請輸入兩個操作數(shù):>");
			scanf("%d %d", &x, &y);
			int ret = arr[input](x, y);
			printf("%d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出游戲!\n");
		}
		else
			printf("選擇錯誤!\n");
	} while (input);
	return 0;
}

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
int main()
{
	int (*pf)(int, int) = Add;//pf是函數(shù)指針
	int (*arr[4])(int, int) = { Add,Sub,Mul,Div };//arr就是函數(shù)指針的數(shù)組
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int ret = arr[i](8, 4);
		printf("%d\n", ret);
	}
	return 0;
}

指向函數(shù)指針數(shù)組的指針

指向函數(shù)指針數(shù)組的指針是一個指針。該指針指向一個 數(shù)組 ，數(shù)組的元素都是 函數(shù)指針 ;
如何定義呢？

#include<stdio.h>
void test(const char* str)
{
	printf("%s\n",str);
}
int main()
{
	test("abc");
	void (*ptest)(const char*) = test;//函數(shù)指針ptest
	void (*pparr[3])(const char* str);//函數(shù)指針數(shù)組
	pparr[0] = test;
	void (*(*ppptest)[5])(const char*) = &pparr;//函數(shù)指針數(shù)組指針
	return 0;
}

#include<stdio.h>
int main()
{
	//函數(shù)指針數(shù)組
	int (*pfArr[])(int, int) = { 0,Add,Sub,Mul,Div };
	//指向函數(shù)指針數(shù)組的指針
	int (*(*ppfArr)[5])(int, int) = &pfArr;
	return 0;
}

回調(diào)函數(shù)

回調(diào)函數(shù)就是一個通過函數(shù)指針調(diào)用的函數(shù)。如果你把函數(shù)的指針（地址）作為參數(shù)傳遞給另一個函數(shù)，當這個指針被用來調(diào)用其所指向的函數(shù)時，我們就說這是回調(diào)函數(shù)。回調(diào)函數(shù)不是由該函數(shù)的實現(xiàn)方直接調(diào)用，而是在特定的事件或條件發(fā)生時由另外的一方調(diào)用的，用于對該事件或條件進行響應(yīng)。

簡單的冒泡排序

冒泡排序只能排序整型數(shù)據(jù)。

#include<stdio.h>
void bubble_sort(int arr[], int sz)
{
	int i = 0;
	//趟數(shù)
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		//一趟
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

可是有缺點，當數(shù)組arr[]本來就是升序數(shù)組，一樣要按照未排序的數(shù)組進行。

冒泡排序的優(yōu)化

void bubble_sort(int arr[], int sz)
{
	int i = 0;
	//趟數(shù)
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		int flag = 1;
		//一趟
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flag = 0;
			}
			if (flag == 1)
			{
				break;
			}
		}
	}
}

盡管這樣，冒泡排序只能排序整型數(shù)組，限制太多，可以運用qsort函數(shù)快排

qsort函數(shù)

qsort函數(shù)介紹

qsort使用快速排序的思想實現(xiàn)的一個排序的函數(shù)。

void* base

指向要排序的數(shù)據(jù)的起始位置。

size_t num

待排序的數(shù)據(jù)元素的個數(shù)。

size_t width

待排序的數(shù)據(jù)元素的大?。▎挝皇亲止?jié)）

int (*compare)(const void *elem1, const void *elem2 )

函數(shù)指針，比較函數(shù)。e1指向一個整型，e2指向另一個整型。

該函數(shù)的返回值是整型：

• 當elem1小于elem2時，返回值是小于0的。

• 當elem1等于elem2時，返回值是0。

• 當elem1大于elem2時，返回值是大于0的。

qsort這個函數(shù)可以排序任意類型的數(shù)據(jù)。qsort默認為升序。

qsort實現(xiàn)冒泡排序

#include<stdio.h>
#include<stdlib.h>
int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - *(int*)e2);
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

int a = 10;
void* pv = &a;//voi*是無具體類型的指針，可以接受任意類型的地址。
//void* 是無懼類型的指針，所以不能解引用操作，也不能+-整數(shù)

qsort排序結(jié)構(gòu)數(shù)據(jù)

按名字升序

#include<stdio.h>
#include<stdlib.h>
struct Stu
{
	char name[20];
	int age;
};
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void test()
{
	struct Stu s[] = { {"zhangsan",15},{"lisi",30},{"wangwu",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
	struct Stu* p1 = s;
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s,%d\n", s[i].name, s[i].age);
	}
}
int main()
{
	test();
	return 0;
}

按年齡升序

#include<stdio.h>
#include<stdlib.h>
struct Stu
{
	char name[20];
	int age;
};
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age-((struct Stu*)e2)->age;//通過改變e1和e2位置來改變升序和降序
}
void test()
{
	struct Stu s[] = { {"zhangsan",15},{"lisi",30},{"wangwu",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
	struct Stu* p1 = s;
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s,%d\n", s[i].name, s[i].age);
	}
}
int main()
{
	test();
	return 0;
}

模擬實現(xiàn)qsort函數(shù)

排序整型

void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void bubble_sort(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2))
{
	int i = 0;
	//趟數(shù)
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;//假設(shè)數(shù)組是排好序
		//一趟冒泡排序的過程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				//交換
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
				flag = 0;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}
void test1()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	test1();
	return 0;
}

排序結(jié)構(gòu)體

#include<stdio.h>
#include<stdlib.h>
struct Stu
{
	char name[20];
	int age;
};
void cmp_int(const void* e1, const void* e2)
{
	return *((int*) e1) - *((int*)e2);
}
void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void bubble_sort(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2))
{
	int i = 0;
	//趟數(shù)
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;//假設(shè)數(shù)組是排好序
		//一趟冒泡排序的過程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				//交換
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
				flag = 0;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
	//strcmp --> >0 ==0 <0
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void test3()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	//0 1 2 3 4 5 6 7 8 9
	//把數(shù)組排成升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
void test4()
{
	//測試使用qsort來排序結(jié)構(gòu)數(shù)據(jù)
	struct Stu s[] = { {"zhangsan", 15}, {"lisi", 30}, {"wangwu", 25} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s,%d\n", s[i].name, s[i].age);
	}
	printf("\n");
	bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_age);
	for (i = 0; i < sz; i++)
	{
		printf("%s,%d\n", s[i].name, s[i].age);
	}
	printf("\n");
}
int main()
{
	test3();
	test4();
	return 0;
}

到此，相信大家對“C語言指針與qsort函數(shù)怎么使用”有了更深的了解，不妨來實際操作一番吧！這里是億速云網(wǎng)站，更多相關(guān)內(nèi)容可以進入相關(guān)頻道進行查詢，關(guān)注我們，繼續(xù)學習！