文章目录
前言
在指针的简单了解这篇文章中，我们知道了指针的基本概念
- 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
- 指针的大小是固定的4/8个字节（32位平台/64位平台）。
- 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
- 指针的运算。
本文将继续深入探讨指针。
1.字符指针
在指针的类型中我们知道有一种指针类型为字符指针char*；
一般使用：
int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}
还有一种使用方式如下：
int main()
{
const char* pstr = "hello xiaobite.";//这里是把一个字符串放到pstr指针变量里了吗？
printf("%s\n", pstr);
return 0;
}
代码const char* pstr = "hello xiaobite.";
特别容易让我们以为是把字符串hello xiaobite.放到了字符指针pstr里了，但是本质是把字符串hello xiaobite.首字符的地址地址放到了pstr中。
上面代码的意思是把一个常量字符串的首字符h的地址存放到指针变量pstr中。
那就有这样一个题：
#include <stdio.h>
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char* str3 = "hello bit.";
const char* str4 = "hello bit.";
if (str1 == str2)
printf("str1 and str2 are same\n");
else
printf("str1 and str2 are not same\n");
if (str3 == str4)
printf("str3 and str4 are same\n");
else
printf("str3 and str4 are not same\n");
return 0;
}
这里是输出结果：
这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。
2. 指针数组
指针数组顾名思义就是一个存放指针的数组。
在前面指针的简单了解这里我们也提到过，这里我们复习一下，下面的指针数组分别是什么意思？
int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组
3. 数组指针
3.1 数组指针的定义
数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。
下面代码哪个是数组指针？
int *p1[10]; //这是一个数组，里面有包含十个元素，每个元素的类型是int*
int (*p2)[10]; //这是一个指针，指向的类型是int [10]
//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指
向一个数组，叫数组指针。
//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
3.2 &数组名VS数组名
对于下面的数组：
int arr[10];
arr和&arr分别是什么？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？
我看一段代码：
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr);
printf("%p\n", &arr);
return 0;
}
运行结果如下：
可见数组名和&数组名打印的地址是一样的。
难道两个是一样的吗？
我们再看一段代码：
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("arr = %p\n", arr);
printf("&arr= %p\n", &arr);
printf("arr+1 = %p\n", arr + 1);
printf("&arr+1= %p\n", &arr + 1);
return 0;
}
根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。
实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）
本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型
数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.
3.3 数组指针的使用
那数组指针是怎么使用的呢？
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
看代码：
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
int(*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
//但是我们一般很少这样写代码,数组指针一般用在二维数组的传参中
return 0;
}
⭐️： 二维数组的每一行可以理解为二维数组的一个元素，而每一行又是一个一维数组。所以，二维数组其实是一维数组的数组。
一个数组指针的使用：
#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
void print_arr2(int(*arr)[5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
print_arr1(arr, 3, 5);
//数组名arr，表示首元素的地址
//但是二维数组的首元素是二维数组的第一行
//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
//可以数组指针来接收
print_arr2(arr, 3, 5);
return 0;
}
📖：二维数组的数组名，也是数组名，数组名就是数组首元素的地址，而二维数组的首元素地址也就是第一行的地址，第一行是一个一维数组，所以我们传参时，应该使用一个存放该一维数组的指针来接收。
学了指针数组和数组指针我们来一起回顾并看看下面代码的意思：
int arr[5]; //这是一个存放int类型的数组，大小为5
int *parr1[10]; //这是一个存放int*类型的数组，大小为10
int (*parr2)[10]; //这是一个指向类型为int [10]的指针
int (*parr3[10])[5]; //这时一个存放int* [5]类型的数组，大小为10
4. 数组参数、指针参数
在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？
4.1 一维数组传参
我们来看一下以下几种函数，哪些可以接收我们传的参数
#include <stdio.h>
void test(int arr[])//ok?
{}//该函数可以接收arr数组
void test(int arr[10])//ok?
{}//该函数可以接收arr数组
void test(int* arr)//ok?
{}//该函数可以接收arr数组
void test2(int* arr[20])//ok?
{}//该函数可以接收arr2数组
void test2(int** arr)//ok?
{}//该函数可以接收arr2数组
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test(arr);
test2(arr2);
}
总结：数组传参，形参的部分可以是数组，也可以是指针。但其实本质上传过去的是地址，接收的是指针，写成数组的形式接收是为了方便初学者容易理解，但形参部分也不是真正的开辟了一片与该数组大小相同的空间，所以这也是为什么形参部分数组大小可以省略的原因。（这里值得注意的是，二维数组传参，行可以省略，但列不能省略，具体原因我们在下面分析）
4.2 二维数组传参
void test(int arr[3][5])//ok？
{}//该函数可以接收arr数组
void test(int arr[][])//ok？
{}//该函数不能接收arr数组
void test(int arr[][5])//ok？
{}//该函数可以接收arr数组
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr)//ok？
{}//该函数不能接收arr数组
void test(int* arr[5])//ok？
{}//该函数不能接收arr数组
void test(int(*arr)[5])//ok？
{}//该函数可以接收arr数组
void test(int** arr)//ok？
{}//该函数不可以接受arr数组
int main()
{
int arr[3][5] = { 0 };
test(arr);
}
相信也有不少人刚学二维数组传参给一个函数的时候，也搞不清楚为什么二级指针或者指针数组不能够作为二维数组的形参，而数组指针才能够作为二维数组的形参，所以这里我们来解释一下吧：
- 因为数组的传参本质上是把地址给传过去，应该是用指针接收。而指针数组虽然可以用来模拟二维数组，但指针数组是一个数组，所以不能使用它来当形参接收二维数组。
- 在前面我们说到二维数组的数组名是它首元素的地址（也就是第一行的地址），而第一行是一个一维数组，即：
int(*p)[num]（这里的num代表一维数组的元素个数）才是指向二维数组的指针。而int** p不是指向二维数组，而是指向一个int型指针的指针
⭐️：因为数组传参的本质上是指针来接受，而这里是用一个数组指针int (*p)[num]接收，这里num不能省略，因为num表示的是一维数组元素的个数，num不同代表的类型也不同。这里也解释了为什么二维数组传参，行可以省略，但列不能省略了。
4.3 动态开辟二维数组
虽然说两维数组传参时是用一个数组指针接收，但这里我们需要注意的是：如果我们需要动态开辟一个二维数组，我们还是需要使用一个二级指针来进行开辟，具体方式如下：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int row = 10;
int col = 10;
int** arr = (int**)malloc(sizeof(int*) * row); // 开辟二维数组的行
for (int i = 0; i < row;++i)
{
*(arr + i) = (int*)malloc(sizeof(int) * col); //开辟二维数组每行的列
//注:这里每行的列可以由我们进行控制, 如:
//*(arr + i) = (int*)malloc(sizeof(int) * (i + 1));
}
return 0;
}
这样就开辟成功了，下面这幅图可以帮助大家更好的理解：
⭐️：其实这里我们也并不是真正的开辟二维数组，只是模拟实现了二维数组的功能，实践中我们这样去开辟的实用性会高很多！
4.4 一级指针传参
#include <stdio.h>
void print(int* p, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d\n", *(p + i));
}
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
//一级指针p，传给函数
print(p, sz);
return 0;
}
这串代码是将数组的首元素地址赋值给一个指针，随后将该指针传递进print函数中，在函数中对该指针指向的内容进行操作。
那么我们来思考一个问题：
void test1(int *p)
{}
//test1函数能接收什么参数？
void test2(char* p)
{}
//test2函数能接收什么参数？
test1函数的形参是一个整型指针，所以可以接收一个整型变量的地址，或者接收一个整型指针，或者接收是一个整型数组。
test2函数的形参是一个字符指针，所以可以接受一个字符变量的地址，或者接收一个字符指针，或者接收一个字符数组
4.5 二级指针传参
#include <stdio.h>
void test(int** ptr)
{
printf("num = %d\n", **ptr);
}
int main()
{
int n = 10;
int*p = &n;
int **pp = &p;
int* arr[5] = { 0 };//有5个元素，每个元素为int*类型
test(arr);
test(pp);
test(&p);
return 0;
}
那么我们开思考一个问题，当函数的参数为二级指针的时候，可以接收什么参数。
void test(char** p)
{
//...
}
int main()
{
char c = 'b';
char* pc = &c;
char** ppc = &pc;
char* arr[10];
test(&pc);
test(ppc);
test(arr);//Ok?
return 0;
}
这里是否可以传char* arr[10]呢，答案是肯定的，因为char* arr[10]是一个数组，每个元素的类型是char*，而arr是数组名，代表的是首元素地址，而首元素也就是一个char*类型，也就是传过去的是char*的地址，所以应该使用char**来接收。
5. 函数指针
函数指针：顾名思义，就是指向一个函数的指针。
首先我们先来看一段代码：
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}
输出的结果：
⭐️：由此我们可以得出一个结论，函数名是函数的地址，&函数名也是函数的地址
输出的是两个地址，这两个地址是 test 函数的地址。 那我们的函数的地址要想保存起来，怎么保存？ 下面我们看代码：
void test()
{
printf("Hello world\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();
首先，能给存储地址，就要求pfun1或者pfun2是指针，那哪个是指针？ 答案是:
pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。
pfun2先和后面的()结合，所以pfun2是一个函数，返回类型为void*
我们来练习一下，给一个函数，让一个指针指向该函数，写出该指针的类型：
void test(char* p, int arr[10])
{
//...
}
int main()
{
//写法一:
void (*pf)(char*, int [10]) = &test;
//写法二:
void (*pf)(char*, int*) = &test;
return 0;
}
以上写法都是可以的，函数指针后面的括号里面只要加上类型就可以了，不用写变量名。写法二第二个参数类型可以写成
int*，原因是因为，数组在传参时本质上传递的是地址，所以应该用指针来接收，当然也可以写成数组的形式，这样是因为方便初学者能够理解，但在函数创建时，并不会重新开辟一片数组的空间。
那讲了怎么将函数存入到指针中，我们就来谈谈，这个指针可以怎么用，先看代码：
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*pf)(int, int) = &Add;
int r = Add(3, 4);
printf("%d\n", r);
int m = (*pf)(5, 5);
printf("%d\n", m);
return 0;
}
执行结果如下：
当然，我们也可以讲代码写成这样：
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*pf)(int, int) = Add;
int r = Add(3, 4);
printf("%d\n", r);
int m = pf(5, 5);
printf("%d\n", m);
return 0;
}
运行结果如下：
📖：我们将
Add直接存放在指针pf中了，那么这也就说明了Add和&Add都是函数Add的地址，所以我们不用对指针pf进行解引用就能直接使用了。所以我们使用指针pf时，就不用使用*了，这里的*就是一个摆设，加几个*都可以，但如果我们使用*时，一定要带括号，否则就会报错,。
阅读两段有趣的代码：
//代码1
(* (void (*)())0 )();
//代码2
void (*signal(int , void(*)(int)))(int);
首先我们要先知道，一个地址大概是这样一个形式：
0x010FFCEC，它表示的是一个地址（int*），但也可以表示一个整型（int），只不过他是十六进制表示的而已。
代码一：
0默认是一个整型类型，而我们强制类型转换成了一个void (*)()类型（这是一个函数指针类型，指向的是一个没有参数，返回类型是void的函数），那么就认为0地址处放有这个类型的函数，然后再对该函数进行解引用，调用0地址处的这个函数。
代码二：
这是一个函数声明，函数名是signal，第一个参数是int类型，第二个参数是void(*)(int)函数指针类型，而这个函数的返回类型是void(*)(int)函数指针类型。
我们可以简化这串代码，就方便理解了。我们可以将void(*)(int)类型重定义成pfun_t，那这时，就可以这样写：
typedef void (*pfun_t)(int); //这里是将void (*)(int)类型转换成pfun_t
pfun_t signal(int, pfun_t);
6. 函数指针数组
数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，比如：
int *arr[10];
//数组的每个元素是int*
那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？
int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];
答案是：parr1 ；parr1 先和 [] 结合，说明 parr1是数组，数组的内容是什么呢？ 是 int (*)() 类型的函数指针。
函数指针数组的用途：转移表
例子：（计算器）
我们在实现计算器的时候，大致思路是这样的：
#include <stdio.h>
void meun()
{
printf("*************************\n");
printf("****** 1:add 2:sub ******\n");
printf("****** 3:mul 4:div ******\n");
printf("****** 0:exit ******\n");
printf("*************************\n");
}
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)
{
return a / b;
}
int main()
{
int x, y;
int input = 1;
int ret = 0;
do
{
menu();
printf("请选择：");
scanf("%d", &input);
if (input >= 1 && input <= 4)
{
printf("输入操作数：");
scanf("%d %d", &x, &y);
}
switch (input)
{
case 1:
ret = add(x, y);
break;
case 2:
ret = sub(x, y);
break;
case 3:
ret = mul(x, y);
break;
case 4:
ret = div(x, y);
break;
case 0:
printf("退出程序\n");
break;
default:
printf("选择错误\n");
break;
}
if (input >= 1 && input <= 4)
{
printf("ret = %d\n", ret);
}
} while (input);
return 0;
}
因为这几个函数的类型和参数都是一样的，所以我们也可以使用函数指针数组来完成：
#include <stdio.h>
void meun()
{
printf("*************************\n");
printf("****** 1:add 2:sub ******\n");
printf("****** 3:mul 4:div ******\n");
printf("****** 0:exit ******\n");
printf("*************************\n");
}
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)
{
return a / b;
}
int main()
{
int x, y;
int input = 1;
int ret = 0;
int (*pfun_t[5])(int, int) = { NULL, add,sub,mul,div };
do
{
meun();
printf("请选择：");
scanf("%d", &input);
if (input >= 1 && input <= 4)
{
printf("输入操作数：");
scanf("%d %d", &x, &y);
ret = pfun_t[input](x, y);
printf("ret = %d\n", ret);
}
else if (input == 0)
printf("退出程序\n");
else
printf("选择错误,请重新选择\n");
} while (input);
return 0;
}
我们这样写，可以看到，代码大幅度的减少了，并且以后如果我们要增加其他的功能，也只用稍微修改一下代码就行了。
7. 指向函数指针数组的指针
指向函数指针数组的指针是一个指针指针指向一个 数组 ，数组的元素都是函数指针
如何定义？
void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针pfun
void (*pfun)(const char*) = test;
//函数指针的数组pfunArr
void (*pfunArr[5])(const char* str);
pfunArr[0] = test;
//指向函数指针数组pfunArr的指针ppfunArr
void (*(*ppfunArr)[5])(const char*) = &pfunArr;
return 0;
}
⭐️：虽然说这些东西我们并不常见，但是这些也是语法支持的，在以后遇到的时候，我们应该学会去读懂这些复杂的代码。
如图，我们继续这样套娃下去都是可以的，但是也没必要了，这里大家就简单看看就行了，不用管是什么意思：
8. 回调函数
8.1 回调函数的概念
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
这里我们可以将前面的计算器代码改造一下：
#include <stdio.h>
//回调函数的运用
void Calc(int (*pfun_t)(int, int))
{
int x = 0;
int y = 0;
int ret = 0;
printf("输入操作数:");
scanf("%d %d", &x, &y);
ret = pfun_t(x, y);
printf("ret = %d\n", ret);
}
void meun()
{
printf("*************************\n");
printf("****** 1:add 2:sub ******\n");
printf("****** 3:mul 4:div ******\n");
printf("****** 0:exit ******\n");
printf("*************************\n");
}
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)
{
return a / b;
}
int main()
{
int x, y;
int input = 1;
int ret = 0;
do
{
meun();
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;
}
从这段代码中，我们可以看到它的调用逻辑是将add、sum、mul、div这几个函数的传参给Calc函数中去，而Calc函数中用int (*pfun_t)(int, int)接收这些函数，并在Calc函数中使用接收过来的函数。这就是回调函数。
8.2 qsort函数的使用
这里我们介绍一个函数qsort，并展示它的用法。点这里详细了解qsort。
由图，我们可以看到，qsort函数总的有四个参数，那我们就来聊一聊这四个参数分别代表什么意思：
void qsort(void* base, //指向我们要排序的数组的第一个元素
size_t num, //数组的元素个数
size_t size,//每个元素的大小0
int (*compar)(const void*, const void*));//函数指针类型 —— 这个函数指针指向的函数，能够比较base指向数组中的两个元素
//这个函数是由我们使用者自己去实现
我们再来看：这个比较函数是有两个参数,是有两个参数的，两个参数的类型如下：
int compar(cost void* p1, const void* p2)
⭐️：这两个参数中的指针指向的内容是要比较的两个元素的地址。
我们还注意到，这个比较函数，返回类型是int，具体是返回什么呢?
| 返回值 | 意思 |
|---|---|
| <0 | p1指向的元素小于p2指向的元素 |
| 0 | p1指向的元素等于p2指向的元素 |
| >0 | p1指向的元素大于p2指向的元素 |
⭐️： 这里我们来了解一下
void*指针：
这种类型的指针是不能直接进行解引用操作的
也不能直接进行指针运算的
void*指针，可以理解为无具体类型的指针，可以接收任意类型的地址
讲了那么多，那我们就先来测试一下qsort函数的一个使用吧，先看代码：
#include <stdio.h>
#include <stdlib.h>
//这里由我们使用者自己构造一个函数
//由于我们是使用者,所以我们知道要比较的元素是什么类型的
//要满足以下条件：
//如果第一个元素大于第二个元素就返回一个大于0的数
//如果第一个元素等于第二个元素就返回一个等于0的数
//如果第一个元素小于第二个元素就返回一个小于0的数
int cmp_int(const void* p1, const void* p2)
{
//这里我们是将p1,p2强制转换成我们比较的类型,然后直接相减,就能得到满足条件的值了
return (*(const int*)p1 - *(const int*)p2);
}
int main()
{
int arr[10] = { 9,5,7,8,6,4,2,3,1,0 };
int num = sizeof(arr) / sizeof(arr[0]);//计算元素个数
int size = sizeof(int);
int i = 0;
printf("排序前:\n");
for (i = 0;i < num;i++)
{
printf("%d ", arr[i]);
}
qsort(arr, num, size, cmp_int);
printf("\n排序后\n");
for (i = 0;i < num;i++)
{
printf("%d ", arr[i]);
}
return 0;
}
效果如图所示：
当然，我们可以看到qsort函数的参数中的函数指针，它所指向的比较函数中的形参void*指针，而我们在上面讲了，void*指针可以指向任意类型的地址。所以我们知道，qsort函数可以排序任意类型，是不是这样呢？我们继续来测试一下：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Stu
{
char name[20];//名字
int age;//年龄
char id[10];//学号
};
//用名字进行比较的函数
int cmp_name(const void* p1, const void* p2)
{
//在C语言中比较字符串的大小，应该用strcmp函数
return (strcmp(((const struct Stu*)p1)->name, ((const struct Stu*)p2)->name));
}
//用年龄进行比较的函数
int cmp_age(const void* p1, const void* p2)
{
return (((struct Stu*)p1)->age - ((struct Stu*)p2)->age);
}
//用学号进行比较的函数
int cmp_id(const void* p1, const void* p2)
{
return (strcmp(((const struct Stu*)p1)->id, ((const struct Stu*)p2)->id));
}
int main()
{
//定义几个学生变量
struct Stu student[3] = { {"Zhangsan",18,"222045001"},{"Lisi",20,"222045002"},{"Wangwu",19,"222045003"} };
int num = sizeof(student) / sizeof(student[0]);
int size = sizeof(student[0]);
int i = 0;
//按照名字进行排序
qsort(student, num, size, cmp_name);
printf("用名字进行排序:\n\n");
printf("姓名\t\t年龄\t学号\n");
for (i = 0;i < num;i++)
{
printf("%-8s\t%d\t%5s\n", student[i].name, student[i].age, student[i].id);
}
//按照年龄进行排序
qsort(student, num, size, cmp_age);
printf("\n用年龄进行排序:\n\n");
printf("姓名\t\t年龄\t学号\n");
for (i = 0;i < num;i++)
{
printf("%-8s\t%d\t%5s\n", student[i].name, student[i].age, student[i].id);
}
//按照学号进行排序
qsort(student, num, size, cmp_id);
printf("\n用学号进行排序:\n\n");
printf("姓名\t\t年龄\t学号\n");
for (i = 0;i < num;i++)
{
printf("%-8s\t%d\t%5s\n", student[i].name, student[i].age, student[i].id);
}
return 0;
}
运行结果如下：
8.3 用冒泡排序模拟实现qsort
看到这里的人，想必大家对冒泡排序都不陌生，这里简单的给大家实现一遍：
void bubble_sort(int* arr, int sz)
{
assert(arr != NULL);//断言,不能将空指针传到该函数中
int i = 0;
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;//如果一趟还没有排序完，就将标记置为0
}
}
//如果一趟下来没有发生变化，证明已经排序成果，不需要再继续排序
if (flag == 1)
break;
}
}
我们一般的实现逻辑是这样，但是可以看出，相较于qsort函数（我们暂且不考虑效率问题），我们这个能排序的类型就很局限了，只能排序int类型，而qsort函数我们经过上面的测试，可以看出它能够排序任意类型。那我们能否改造一下我们的冒泡排序，让它也能够排序任意类型呢？
当然是可以的，看代码：
#include <stdio.h>
#include <string.h>
struct Stu
{
char name[20];//名字
int age;//年龄
char id[10];//学号
};
void Swap(char* p1,char* p2, size_t size)
{
//因为我们不知道传过来的元素有多大，所以我们就每次交换一对字节
//循环size次，就能够将两个元素交换了
int i = 0;
for (i = 0;i < size;i++)
{
char tmp = *p1;
*p1 = *p2;
*p2 = tmp;
//交换完一对字节地址往后移一位,直到交换完size个字节,就完成了两个元素的交换
p1++;
p2++;
}
}
void bubble_sort(void* base, size_t num, size_t size,int (*compar)(const void*, const void*))
{
int i = 0;
//趟数
for (i = 0;i < num - 1;i++)
{
int j = 0;
//每一趟内部比较的对数
for (j = 0;j < num - 1 - i;j++)
{
//因为我们不知道会传递过来什么类型,就不知道应该要用什么方式进行比较
//所以我们将比较单独构成一个函数,让使用者去实现
//返回一个大于0的数就进行交换
//返回的是一个小于等于0的就不用交换
if (compar(((const char*)base + j * size), ((const char*)base + (j + 1) * size)) > 0)
{
//这里因为void*不能直接进行指针运算,所以我们强制类型转换成char*类型
//这里转成char*的好处是,我们可以直接加上一个元素的宽度size,就可以指向我们想要的元素了
Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
//这里我们单独实现一个交换函数,因为我们不知道会交换什么类型的元素
//所以我们将需要比较的两个元素和元素大小传递过去
}
}
}
}
//用名字进行比较的函数
int cmp_name(const void* p1, const void* p2)
{
//在C语言中比较字符串的大小，应该用strcmp函数
return (strcmp(((const struct Stu*)p1)->name, ((const struct Stu*)p2)->name));
}
//用年龄进行比较的函数
int cmp_age(const void* p1, const void* p2)
{
return (((struct Stu*)p1)->age - ((struct Stu*)p2)->age);
}
//用学号进行比较的函数
int cmp_id(const void* p1, const void* p2)
{
return (strcmp(((const struct Stu*)p1)->id, ((const struct Stu*)p2)->id));
}
int main()
{
struct Stu student[3] = { {"Zhangsan",18,"222045001"},{"Lisi",20,"222045002"},{"Wangwu",19,"222045003"} };
int num = sizeof(student) / sizeof(student[0]);
int size = sizeof(student[0]);
int i = 0;
//按照名字进行排序
bubble_sort(student, num, size, cmp_name);
printf("用名字进行排序:\n\n");
printf("姓名\t\t年龄\t学号\n");
for (i = 0;i < num;i++)
{
printf("%-8s\t%d\t%5s\n", student[i].name, student[i].age, student[i].id);
}
//按照年龄进行排序
bubble_sort(student, num, size, cmp_age);
printf("\n用年龄进行排序:\n\n");
printf("姓名\t\t年龄\t学号\n");
for (i = 0;i < num;i++)
{
printf("%-8s\t%d\t%5s\n", student[i].name, student[i].age, student[i].id);
}
//按照学号进行排序
bubble_sort(student, num, size, cmp_id);
printf("\n用学号进行排序:\n\n");
printf("姓名\t\t年龄\t学号\n");
for (i = 0;i < num;i++)
{
printf("%-8s\t%d\t%5s\n", student[i].name, student[i].age, student[i].id);
}
return 0;
}
效果如图所示：
到这里，指针的基本内容也已经讲完了，接下来我们做点题巩固一下吧！
9. 指针和数组笔试题解析
⭐️：数组名的意义：
- sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
- &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
- 除此之外所有的数组名都表示首元素的地址。
第一题:
#include <stdio.h>
int main()
{
//一维数组
int a[] = { 1,2,3,4 };
printf("%d\n", sizeof(a)); //这里的a表示的是整个数组的大小,所以应该是16
printf("%d\n", sizeof(a + 0)); //(a + 0)进行了算术运算,所以在这里a代表的是首元素的地址大小
printf("%d\n", sizeof(*a)); //表示数组首元素地址进行解引用操作,结果是int类型的大小
printf("%d\n", sizeof(a + 1)); //(a + 1)进行了算术运算,所以这里表示的是第二个元素的地址大小
printf("%d\n", sizeof(a[1])); //表示的是第二个元素,结果为int类型的大小
printf("%d\n", sizeof(&a)); //&a表示整个数组的地址,所以这里计算的是地址的大小
printf("%d\n", sizeof(*&a)); //这里可以看成*(&a),拿到一个数组的地址,然后再解引用,这里的*&相当于抵消了,所以结果应该是sizeof(a)
printf("%d\n", sizeof(&a + 1)); //(&a + 1)表示跳过整个数组的地址,指向数组最后一个元素后面的地址,但也是表示一个地址
printf("%d\n", sizeof(&a[0])); //这里表示的是取出第一个元素的地址
printf("%d\n", sizeof(&a[0] + 1));//这里表示的是指向第二个元素的地址
return 0;
}
第二题：
#include <stdio.h>
int main()
{
//字符数组
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(arr)); //这里的arr表示的是整个数组,所以这里应该是6
printf("%d\n", sizeof(arr + 0)); //(arr + 0)进行了算术运算,所以在这里arr代表的是首元素的地址大小
printf("%d\n", sizeof(*arr)); //表示数组首元素地址进行解引用操作,结果是char类型的大小
printf("%d\n", sizeof(arr[1])); //表示的是第二个元素,结果为char类型的大小
printf("%d\n", sizeof(&arr)); //&arr表示整个数组的地址,所以这里计算的是地址的大小
printf("%d\n", sizeof(&arr + 1)); //(&arr + 1)表示跳过整个数组的地址,指向数组最后一个元素后面的地址,但也是表示一个地址
printf("%d\n", sizeof(&arr[0] + 1));//这里表示的是指向第二个元素的地址
printf("%d\n", strlen(arr));//这里是产生一个随机数,因为strlen要找到'\0'的位置才停下,而我们这样定义字符数组末尾没有'\0'
printf("%d\n", strlen(arr + 0));//这里的结果和strlen(arr)是一样的
//printf("%d\n", strlen(*arr));//这里的表达是错误的,因为strlen传参,应该传一个地址,而这里传的是首元素
//printf("%d\n", strlen(arr[1]));//这里的表达是错误的,因为strlen传参,应该传一个地址,而这里传的是第二个元素
printf("%d\n", strlen(&arr));
printf("%d\n", strlen(&arr + 1));
printf("%d\n", strlen(&arr[0] + 1));
//以上三个得到的都是随机值
return 0;
}
第三题：
#include <stdio.h>
int main()
{
char arr[] = "abcdef";
printf("%d\n", sizeof(arr));//这里的arr表示的是整个数组, 所以这里应该是7(结尾有一个'\0')
printf("%d\n", sizeof(arr + 0));//(arr + 0)进行了算术运算,所以在这里arr代表的是首元素的地址大小
printf("%d\n", sizeof(*arr));//表示数组首元素地址进行解引用操作,结果是char类型的大小
printf("%d\n", sizeof(arr[1]));//表示的是第二个元素,结果为char类型的大小
printf("%d\n", sizeof(&arr)); //&arr表示整个数组的地址,所以这里计算的是地址的大小
printf("%d\n", sizeof(&arr + 1));//(&arr + 1)表示跳过整个数组的地址,指向数组最后一个元素后面的地址,但也是表示一个地址
printf("%d\n", sizeof(&arr[0] + 1));//这里表示的是指向第二个元素的地址
printf("%d\n", strlen(arr));//我们这样定义字符串,末尾自动跟一个'\0',所以这里应该是6
printf("%d\n", strlen(arr + 0));//这里的结果和strlen(arr)是一样的
//printf("%d\n", strlen(*arr));//这里的表达是错误的,因为strlen传参,应该传一个地址,而这里传的是首元素
//printf("%d\n", strlen(arr[1]));//这里的表达是错误的,因为strlen传参,应该传一个地址,而这里传的是第二个元素
printf("%d\n", strlen(&arr));//这里虽然是取出整个数组的地址,但传递给strlen做参数时,也强转成了const char*,所以也会从第一个元素往后找'/0',所以结果应该是6
printf("%d\n", strlen(&arr + 1));//这里访问的是未定义的空间,所以结果是一个随机值
printf("%d\n", strlen(&arr[0] + 1));//这里是从第二个元素开始往后找'\0'所以结果是5
return 0;
}
第四题：
#include <stdio.h>
int main()
{
char* p = "abcdef";
printf("%d\n", sizeof(p));//这里的p表示的是一个字符指针,指向的是第一个元素的地址
printf("%d\n", sizeof(p + 1));//(p + 1)表示的是第二个元素的地址
printf("%d\n", sizeof(*p));//这里表示对第一个元素进行解引用操作,大小为char类型的大小
printf("%d\n", sizeof(p[0]));//这里表示访问第一个元素,大小为char类型的大小
printf("%d\n", sizeof(&p));//这里表示取出指针变量p的地址,结果也应该是一个指针的大小
printf("%d\n", sizeof(&p + 1));//这里得到的应该是b的地址大小,因为(&p + 1)是跳过一个char*类型,而跳过一个char*就指向了字符'b'的地址
printf("%d\n", sizeof(&p[0] + 1));//(&p[0] + 1)是对p指向的元素取地址,再向后移一位,指向的是'b'的地址
printf("%d\n", strlen(p));// 6
printf("%d\n", strlen(p + 1));// 5
printf("%d\n", strlen(*p));//这里的表达是错误的,因为strlen传参,应该传一个地址,而这里传的是首元素
printf("%d\n", strlen(p[0]));//这里的表达是错误的,因为strlen传参,应该传一个地址,而这里传的是首元素
printf("%d\n", strlen(&p));//随机数,&p是char**类型的,此时已经指向了其他空间,我们不能判断在哪里会出现'\0'
printf("%d\n", strlen(&p + 1));//随机数,&p是char**类型的,此时已经指向了其他空间,我们不能判断在哪里会出现'\0'
printf("%d\n", strlen(&p[0] + 1));// 5
return 0;
}
第五题：
#include <stdio.h>
int main()
{
//二维数组
int a[3][4] = { 0 };
printf("%d\n", sizeof(a));//这里的数组名a表示整个数组,所以大小为48
printf("%d\n", sizeof(a[0][0]));//a[0][0]表示第一行第一个元素,大小为4个字节
printf("%d\n", sizeof(a[0]));//a[0]是第一行这个一维数组的数组名,这里的数组名是单独放在sizeof中,所以这里的代表的整个一维数组的地址
printf("%d\n", sizeof(a[0] + 1));//a[0]作为第一行的数组名,没有单独放在sizeof内部,+1进行了算术运算,
//所以这里a[0]是第一行一维数组的首元素地址a[0][0]的地址,(a[0]+1)表示的是(a[0][1])的地址
printf("%d\n", sizeof(*(a[0] + 1)));//*(a[0] + 1)得到的是a[0][0] + 1,结果也是int类型的大小
printf("%d\n", sizeof(a + 1));//这里的a没有单独放在sizeof内部,所以a表示二维数组的首元素地址就是第一行的地址,(a+1)表示第二行的地址
printf("%d\n", sizeof(*(a + 1)));//16
//解释一:*(a+1) ==> a[1],就是第二行的数组名
//解释二:a+1是第二行的地址,类型是int (*)[4] *(a+1)访问的就是int [4]类型
printf("%d\n", sizeof(&a[0] + 1));//取出第一行的地址+1就得到的是第二行的地址
printf("%d\n", sizeof(*(&a[0] + 1)));//16;
//(&a[0]+1)是第二行的地址,对它进行解引用就是访问int [4]类型
printf("%d\n", sizeof(*a));//16;
//这里的a不是单独放在sizeof内部,所以表示的是第一行的地址,解引用访问的就是int [4]类型
printf("%d\n", sizeof(a[3]));//16;这里虽然越界了,但a[3]也是int [4]类型的,我们也只是计算大小,并未去访问空间
return 0;
}
10. 指针笔试题
笔试题1：
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int *)(&a + 1);
printf( "%d,%d", *(a + 1), *(ptr - 1));
return 0;
}
//程序的结果是什么？
答案：
笔试题2：
//这里先告知该结构体大小为20个字节
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p = (struct Test*)0x100000;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
printf("%p\n", p + 0x1);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
return 0;
}
答案：
笔试题3：
int main()
{
int a[4] = { 1, 2, 3, 4 };
int* ptr1 = (int*)(&a + 1);
int* ptr2 = (int*)((int)a + 1);
printf("%x,%x", ptr1[-1], *ptr2);
return 0;
}
答案：
这里我们首先分析ptr1[-1]:
再分析ptr2之前，最好先了解一下大小端的概念，如果不了解，可以看看《数据的存储》这篇博客，了解的话可以直接看下面的解析：
笔试题4：
#include <stdio.h>
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };
int* p;
p = a[0];
printf("%d", p[0]);
return 0;
}
答案：
笔试题5：
int main()
{
int a[5][5];
int(*p)[4];
p = a;
printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
return 0;
}
答案：
笔试题6：
int main()
{
int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int *ptr1 = (int *)(&aa + 1);
int *ptr2 = (int *)(*(aa + 1));
printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
return 0;
}
答案：
笔试题7：
#include <stdio.h>
int main()
{
char* a[] = { "work","at","alibaba" };
char** pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}
笔试题8：
int main()
{
char* c[] = { "ENTER","NEW","POINT","FIRST" };
char** cp[] = { c + 3,c + 2,c + 1,c };
char*** cpp = cp;
printf("%s\n", **++cpp);
printf("%s\n", *-- * ++cpp + 3);
printf("%s\n", *cpp[-2] + 3);
printf("%s\n", cpp[-1][-1] + 1);
return 0;
}
答案：
注： 这里尤其要注意的是我说的指向和访问两个词，
指向：表达一个指针指向哪里
访问：对某个地址进行解引用操作，访问该地址处的内容
667
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
