9. 模拟实现排序函数
这里我们使用冒泡排序算法，模拟实现一个排序函数，可以排序任意类型的数据。
这段代码可以排序整型数据，我们需要在这段代码的基础上进行改进，使得它可以排序任意类型的数据。
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void bubble_sort(int arr[], int sz)
{
//冒泡排序趟数
int i = 0;
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 temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
void print(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
void test1()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };//升序
int sz = sizeof(arr) / sizeof(arr[0]);
print(arr, sz);//排序前打印
bubble_sort(arr,sz);//排序成降序
print(arr, sz);//排序后打印
}
int main()
{
test1();//排序整型数据
}那么我们要做的就是将bubble_arr里的int arr[]改为指针的形式，并且是void*类型，这样就可以接收任意类型的数据，再将int sz改为size_t类型，仅仅有元素个数还不够，我们还需要知道一个元素的大小，这样可以方便我们访问，所以我们加一个size_t size，最后我们再加一个比较函数int (*cmp)(const void* e1,const void* e2),这是一个函数指针，所以我们需要根据自己的需求写一个比较函数。
e1是一个指针，存放了一个要比较的元素的地址
e2是一个指针，存放了一个要比较的元素的地址
e1指向的元素>e2指向的元素，返回>0的数字
e1指向的元素==e2指向的元素，返回0
e1指向的元素<e2指向的元素，返回<0的数字
1.如果我们要比较整型数据，我们就写一个cmp_int，将const void*强转成（int*）再解引用，然后两个元素进行相减，结果作为这个函数的返回值。由于base的类型是void*，所以不能进行+1，-1，所以我们再将base的类型强转成char*，然后加上j*size，就可以进行每个元素的访问了。我们在进行排序的时候需要将元素交换，所以写一个交换函数swap，将元素的地址和大小传过去就行了。
2.如果我们要比较结构体数据的首字母，我们写一个cmp_stu_by_name作为比较函数，字符串的比较我们用strcmp，返回值是>0,<0或者0。
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void swap(char* buf1, char* buf2, size_t size)
{
int i = 0;
for (i = 0; i < size; i++)
{
char tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
void bubble_sort(void* base, size_t num, size_t size, int (*cmp)(const void* e1, const void*e2))
{
//冒泡排序的趟数
int i = 0;
for (i = 0; i < num - 1; i++)
{
//一趟冒泡排序
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
//if (arr[j] > arr[j + 1])
if(cmp((char*)base + j * size, (char*)base + (j + 1) * size)>0)
{
//交换
swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
}
}
}
}
int cmp_int(const void*e1, const void*e2)
{
return *(int*)e1 - *(int*)e2;
}
void test1()
{
int arr[] = { 0,1,2,3,4,5,6,7,8,9 };//升序
//排序为降序
int sz = sizeof(arr) / sizeof(arr[0]);
print_arr(arr, sz);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
print_arr(arr, sz);
}
struct Stu
{
char name[20];//20
int age;//4
};
int cmp_stu_by_age(const void* e1, const void*e2)
{
return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void test2()
{
struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15}};
int sz = sizeof(arr) / sizeof(arr[0]);//3
bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
//整型数据/字符数据/结构体数据...
//可以使用qsort函数对数据进行排序
//测试bubble_sort，排序整型数据
test1();
//测试bubble_sort，排序结构体的数据
//test2();
return 0;
}10. 指针和数组笔试题解析
一维数组：
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a));数组名的理解：
数组名是数组首元素的地址
但是有2个例外：
1. sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节
2. &数组名，这里的数组名表示整个数组，&数组名取出的是数组的地址
所以答案是4*4=16。
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a+0));a并非单独放在sizeof内部，也没有&，所以数组名a是数组首元素的地址，a+0还是首元素的地址。
只要是地址，大小就是4/8,单位是byte。
int a[] = {1,2,3,4};
printf("%d\n",sizeof(*a));a并非单独放在sizeof内部，也没有&,所以数组名a是数组首元素的地址.*a == *(a+0) == a[0]。
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a+1));a并非单独放在sizeof内部，也没有&，所以数组名a是数组首元素的地址,a+1就是第二个元素的地址。a+1 == &a[1] 是第2个元素的地址，是地址就是4/8个字节。
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a[1]));a[1]就是数组的第二个元素，这里计算的就是第二个元素的大小，单位是字节 - 4
int a[] = {1,2,3,4};
printf("%d\n", sizeof(&a));&a - 是取出数组的地址，但是数组的地址也是地址，是地址就是4/8个Byte。
数组的地址 和 数组首元素的地址 的本质区别是类型的区别，并非大小的区别
a -- int* int * p = a;
&a -- int (*)[4] int (*p)[4] = &a;
int a[] = { 1,2,3,4 };
printf("%d\n", sizeof(*&a));
对数组指针解引用访问一个数组的大小，单位是字节。
sizeof(*&a) --- sizeof(a) //16
int a[] = { 1,2,3,4 };
printf("%d\n", sizeof(&a + 1));&a数组的地址，&a+1还是地址，是地址就是4/8个字节。
int a[] = { 1,2,3,4 };
printf("%d\n", sizeof(&a[0]));
&a[0]是首元素的地址， 计算的是地址的大小 4/8 个字节。
int a[] = { 1,2,3,4 };
printf("%d\n", sizeof(&a[0] + 1));/&a[0]是首元素的地址，&a[0]+1就是第二个元素的地址，大小4/8个字节。
字符数组
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(arr));
随机值，arr是首元素的地址.
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(arr + 0));随机值，arr是首元素的地址, arr+0还是首元素的地址。
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(*arr));err（发生错误），arr是首元素的地址, *arr就是首元素 - 'a' - 97。
站在strlen的角度，认为传参进去的'a'-97就是地址，97作为地址，直接进行访问，就是非法访问。
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(arr[1]));err, 'b' - 98。
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(&arr));随机值
&arr -- char (*)[6]
const char*。
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(&arr + 1));随机值。
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(&arr[0] + 1));随机值。
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(arr));6，数组名arr单独放在sizeof内部，计算的是整个数组的大小，单位是字节。
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(arr + 0));arr是首元素的地址==&arr[0]，是地址就是4/8个字节。
char*
指针变量的大小和类型无关，不管什么类型的指针变量，大小都是4/8个字节。
指针变量是用来存放地址的，地址存放需要多大空间，指针变量的大小就是几个字节。
32位环境下，地址是32个二进制位，需要4个字节，所以指针变量的大小就是4个字节。
64位环境下，地址是64个二进制位，需要8个字节，所以指针变量的大小就是8个字节。
不要在门缝里看指针，把指针给看扁了。
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(*arr));arr是首元素的地址，*arr就是首元素，大小就是1Byte。
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(arr[1]))；1.
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(&arr));&arr是数组的地址，sizeof(&arr)就是4/8个字节。
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(&arr + 1));&arr+1 是跳过数组后的地址，是地址就是4/8个字节。
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(&arr[0] + 1));第二个元素的地址，是地址就是4/8Byte。
char arr[] = "abcdef";
printf("%d\n", sizeof(arr));这个字符串创建的时候末尾必定有一个\0，所以答案是7.
char arr[] = "abcdef";
printf("%d\n", sizeof(arr + 0));arr+0就是第一个元素地址，就是4/8。
char arr[] = "abcdef";
printf("%d\n", sizeof(*arr));arr既没有单独放到sizeof内部，也没有&，所以是首元素地址，就是a的地址，*arr就是取出a的地址，大小就是一个字节。
char arr[] = "abcdef";
printf("%d\n", sizeof(arr[1]));
arr[1]就是第二个元素的地址，所以是1.
char arr[] = "abcdef";
printf("%d\n", sizeof(&arr));&arr就是取出数组的地址，是地址就是4/8个字节。
char arr[] = "abcdef";
printf("%d\n", sizeof(&arr + 1));&arr+1，就是跳过整个数组，但也是地址，就是4/8个字节。
char arr[] = "abcdef";
printf("%d\n", sizeof(&arr[0] + 1));&arr[0]就是取出第一个元素的地址，+1就是第二个元素的地址，就是4/8个字节。
char arr[] = "abcdef";
printf("%d\n", strlen(arr));这个数组名虽然是单独放在strlen内部，但是和sizeof是有区别的，所以代表的是首元素地址，就是a的地址，统计的是\0之前的字符，就是6.
char arr[] = "abcdef";
printf("%d\n", strlen(arr + 0));arr+0代表的是首元素的地址，也是6.
char arr[] = "abcdef";
printf("%d\n", strlen(*arr));对首元素的地址进行解引用，就是a，ASCLL值是97，所以会报错。
char arr[] = "abcdef";
printf("%d\n", strlen(arr[1]));arr[1]是第二个元素，也会报错。
char arr[] = "abcdef";
printf("%d\n", strlen(&arr));取出的是arr的地址，所以是6.
char arr[] = "abcdef";
printf("%d\n", strlen(&arr + 1));
跳过整个数组，把\0也跳过了，因为不知道啥时候遇到\0，所以是随机值。
char arr[] = "abcdef";
printf("%d\n", strlen(&arr[0] + 1));取出的是第二个元素的地址，所以是5.
char* p = "abcdef";
printf("%d\n", sizeof(p));
把a的地址交给了p，p是一个指针变量，所以sizeof(p)就是4/8.
char* p = "abcdef";
printf("%d\n", sizeof(p + 1));char*指针加1就向后跳过一个字节，所以p指向了b，也是地址，所以是4/8.
char* p = "abcdef";
printf("%d\n", sizeof(*p));p是char*的指针，所以解引用访问一个字节，就是1.
char* p = "abcdef";
printf("%d\n", sizeof(p[0]));p[0]是第一个元素，所以也是1.
char* p = "abcdef";
printf("%d\n", sizeof(&p));&p也是地址，地址就是4/8个字节。
char* p = "abcdef";
printf("%d\n", sizeof(&p + 1));&p+1也是地址，所以也是4/8个字节。
char* p = "abcdef";
printf("%d\n", sizeof(&p[0] + 1));
&p[0]+1就是第二个元素的地址，地址就是4/8个字节。
char* p = "abcdef";
printf("%d\n", strlen(p));遇到\0就停止，所以是6.
char* p = "abcdef";
printf("%d\n", strlen(p + 1));从第二个元素开始，所以是5.
char* p = "abcdef";
printf("%d\n", strlen(*p));*p就是a，97，所以会出错。
char* p = "abcdef";
printf("%d\n", strlen(p[0]));p[0]就是第一个元素，也是97，会出错。
char* p = "abcdef";
printf("%d\n", strlen(&p));&p拿到的是随机值。
char* p = "abcdef";
printf("%d\n", strlen(&p + 1));&p+1也是随机值。
char* p = "abcdef";
printf("%d\n", strlen(&p[0] + 1));&p[0]+1，就是第二个元素的地址，所以是5.
今天的分享到这里就结束啦！谢谢老铁们的阅读，让我们下期再见。
