一、结构体成员访问操作符. 与->

① .的使用：结构体变量.成员名

②->的使用：结构体类型指针->成员名

二、两个字符串比较大小

法①：将两个字符串对应的字符从左往右逐个比较，哪个字符的ascll码值大，哪个字符串就大。（与字符串长度无关）例如"abcz"与"abcdeeeff"进行比较时，两个字符串中前三个字符的ascll码值相同，第一个字符串中第四个字符z比第二个字符串中第四个字符d的ascll码值大，因此第一个字符串大。

法②：使用库函数strcmp,它所需要包含的头文件是string.h

三、回调函数

回调函数就是通过函数指针（函数的地址）来调用对应的函数。

例如下面的calc函数就是通过函数指针来调用Add、Sub、Mul、Div这四个函数。

/*设计一个简单的计算器，实现整数的加减乘除*/
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 menu()
{
	printf("*****    1.Add   2.Sub   *****\n");
	printf("*****    3.Mul   4.Div   *****\n");
	printf("*****    0.exit          *****\n");

}
void calc(int(*pf)(int, int))
{
	int x = 0, y = 0, ret = 0;
	printf("请输入两个操作数:");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("%d\n", ret);
}


int main()
{
	int input = 0;
	do
	{
		menu();
		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;
}

四、qsort

①qsort的介绍

qsort是c语言提供的库函数，可以对任意类型的元素进行排序。（默认是从小到大排，但也可以对com函数进行适当改动后，变成从大到小排）使用前要包含头文件stdlib.h

②qsort函数的使用

a.使用qsort函数对整型数组中的元素进行排序

#include<stdlib.h>
int arr_sort(const void* p1, const void* p2)
{  
    //因为p1是void*类型的指针，无法解引用。因此将p1强制转换为int*类型，再对p1进行解引用
    //if (*(int*)p1 > *(int*)p2)  
    //    return 1;
    //else if (*(int*)p1 < *(int*)p2)
    //    return -1;
    //else
     //   return 0;
    return *(int*)p1 - *(int*)p2; //以上代码可以简化成这行代码
}

int main()
{
    int arr[] = { 9,8,7,3,2,1,6,5,4 };
   	size_t sz = sizeof(arr) / sizeof(arr[0]);
    qsort(arr, sz, sizeof(arr[0]), arr_sort);
    for (int i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

b.使用qsort函数对结构体数据进行排序

将"zhangsan" 、“lisi”、"wangwu"的名字进行排序（字符串排序）

#include<stdlib.h>
#include<string.h>
struct student
{
	char name[20];
	unsigned int age;
};
int arr_name(const void* p1, const void* p2)
{
//p1与p2指向的元素都是struct student类型，故这两个元素的地址类型是struct student*类型
//return strcmp(((struct student*)p1)->name,((struct student*)p2)->name);
	return strcmp((*(struct student*)p1).name,(*(struct student*)p2).name);

}

int main()
{
	struct student arr[3] = { {"zhangsan",20},{"lisi",18},{"wangwu",38} };
	//利用结构体类型struct student创建数组arr,数组每个元素的类型都是struct studend
	//将zhangsan、lisi、wangwu的名字进行排序(排序字符串)
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), arr_name);
	return 0;
}

将"zhangsan" 、“lisi”、"wangwu"的年龄进行排序

#include<stdlib.h>
struct student
{
	char name[20];
	unsigned int age;
};
int arr_age(const void* p1, const void* p2)
{
	return (*(struct student*)p1).age - (*(struct student*)p2).age;
    //return ((struct student*)p1)->age - ((struct student*)p2)->age;
}
int main()
{
	struct student arr[3] = { {"zhangsan",20},{"lisi",18},{"wangwu",38} };
	//利用结构体类型struct student创建数组arr
	//将zhangsan、lisi、wangwu的年龄进行排序
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), arr_age);
	return 0;
}

五、利用冒泡排序的思想实现qsort函数

①排序整型元素

int cmp(const void* p1, const void* p2)
{
//p1与p2分别接收需要交换的元素的地址
//若p1指向的元素大返回值为正数
//若p2指向的元素大返回值为负数
//若p1与p2指向的元素一样大，则返回值为0
	return *(int*)p1 - *(int*)p2;
}

void Swap(char* buf1,char* buf2,size_t width)
{
//每个元素占width个字节，将相邻两个元素的width个字节的内容，逐个对应交换
	char m = 0;
	for (int i = 0; i < width; i++)
	{
		m = *buf1;
		*buf1 = *buf2;
		*buf2 = m;
		buf1++, buf2++;
	}
}

void Bubble_sort(void* base, size_t count, size_t width, int(*cmp)(const void* p1, const void* p2))
{
	/* 
	base用于接收待排序数组中首元素的地址
	count用于接收base指向的数组中的元素个数
	width用于接收base指向的数组中每个元素的大小。(单位是字节)
	函数指针cmp用于接收函数的地址，cmp指向的函数用于比较p1指向的元素与p2指向的元素
	*/

	//count个元素需要进行count - 1趟冒泡排序, 每趟解决一个元素，故外面的for循环要循环count - 1次
	for (int i = 0; i < count - 1; i++)
	{
      /*
	  第一趟冒泡排序要进行count - 1对元素的比较
	  第二趟冒泡排序要进行count-2对元素的比较
	  第三趟冒泡排序要进行count-3对元素的比较
	  依此类推
	  */
		for (int j = 0; j < count - 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);
			}
		}
	}
}

int main()
{
	int arr[10] = { 9,8,7,3,2,1,6,5,4,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Bubble_sort(arr, sz, sizeof(arr[0]), cmp);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

②排序结构体类型元素中的字符串

#include<stdio.h>
#include<string.h>
void Swap(char* buf1,char* buf2,size_t width)//p1与p2里面存放的是待比较的两个元素的地址
{
//每个元素占width个字节，将相邻两个元素的width个字节的内容，逐个对应交换
	char m = 0;
	for (int i = 0; i < width; i++)
	{
		m = *buf1;
		*buf1 = *buf2;
		*buf2 = m;
		buf1++, buf2++;
	}
}

void Bubble_sort(void* base, size_t count, size_t width, int(*cmp)(const void* p1, const void* p2))
{
	for (int i = 0; i < count - 1; i++)
	{
		for (int j = 0; j < count - 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);

			}
		}
	}
}

struct student
{
	char name[10];
	size_t age;
};
int String_sort(const void* p1, const void* p2)
{
//p1与p2指向的元素都是struct student类型，故这两个元素的地址类型是struct student*类型
//return strcmp(((struct student*)p1)->name, ((struct student*)p2)->name);
	return strcmp((*(struct student*)p1).name, (*(struct student*)p2).name);
}

int main()
{
	struct student s[3] = { {"zhangsan",18}, {"lisi",20},{"wangwu",10}};
	//利用结构体类型struct student创建数组s,数组每个元素的类型都是struct studend
	//将zhangsan、lisi、wangwu的名字进行排序(排序字符串)
	int sz = sizeof(s) / sizeof(s[0]);
	Bubble_sort(s, sz, sizeof(s[0]), String_sort);
	return 0;
}