目录
一、字符指针
在指针的类型中有一种指针类型为字符指针char*。
一般情况下这样使用：
int main()
{
char ch = 'w';
char* pc = &ch;
*pc = 'w';
return 0;
}还有一种使用方式：
int main()
{
const char* pstr = "zhishu";
printf("%s\n", pstr);
return 0;
}
const char* pstr = "zhishu";
意思是把一个常量字符串的首字符 z
的地址存放到指针变量
pstr
中。
了解了它的使用方式后，来看一道面试题：
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;
}
用相同的常量字符串，初始化不同的数组的时会开辟出不同的内存块，初始化不同的字符指针的时指向的内存块相同。
二、指针数组
指针数组是一个存放指针的数组。
int main()
{
//整型指针的数组
int* arr1[10];
//一级字符指针的数组
char* arr2[4];
//二级字符指针的数组
char** arr[5];
return 0;
}三、数组指针
1.数组指针定义
整形指针：
int * pint
;
能够指向整型数据的指针。
浮点型指针：
float * pf
;
能够指向浮点型数据的指针。
那么，数组指针应该是
能够指向数组的指针
。
int main() { int* p1[9]; int(*p2)[9]; return 0; }p1和p2分别是什么呢？如何区分？
p1是指针数组，p2是数组指针。
int* p1[9]; *与int结合，表示p1是存放了9个int类型指针的数组。
int(*p2)[9]; （ ）有优先级 ，*与p2结合，表示p2是一个指针，指向一个有9个元素的数组。
[ ]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
2.&数组名与数组名
数组名是首元素的地址，但是有两个例外：
- sizeof（数组名）-数组名表示整个数组，计算的是整个数组的大小，单位字节。
- &数组名 -数组名表示整个数组，取出的是整个数组的地址。
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr);
printf("%p\n", &arr);
return 0;
}
输出结果显示，数组名和&数组名打印的地址是一样的，难道它们真的一样吗？
验证一下：
int main()
{
int arr[10] = { 0 };
printf("arr = %p\n", arr);
printf("arr+1 = %p\n", arr + 1);
printf("&arr= %p\n", &arr);
printf("&arr+1= %p\n", &arr + 1);
return 0;
}
0133F964 ——> 0133F968 +4 跨越了一个int类型元素
0133F964 ——> 0133F98C +40 跨越了一个包含10个int类型元素的数组
由此，我们可以知道，虽然上个代码输出的结果相同，但数组名和&数组名的本质是不同的。
3.数组指针的使用
数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int (*p)[10] = &arr;
//把数组arr的地址赋值给数组指针变量p
//但是我们一般很少这样写代码
return 0;
}我们通过打印一个数组来了解一下数组指针如何使用：
void print1(int arr[3][5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
int j = 0;
for (j = 0; j < col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
void print2(int(*arr)[5], int row, int col)
{
int i = 0;
int j = 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 };
print1(arr, 3, 5);
//数组名arr，表示首元素的地址
//但是二维数组的首元素是二维数组的第一行
//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
//可以数组指针来接收
print2(arr, 3, 5);
return 0;
}
特别注意print2中的形参 int(*arr)[5] 为什么这样写，因为二维数组的数组名表示首行元素的地址。
判断：
int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];第一个是：一个包含5个int类型元素的数组。
第二个是：一个包含10个int类型指针的数组。
第三个是：一个指向包含10个int类型元素的数组指针。
第四个是：一个存放数组指针的数组。 parr3[10]是数组，int（*）[5] 是数组指针，把int（*）[5]这个指针存到parr3[10]这个数组里。parr3[10]可以存放10个数组指针。每个数组指针能够指向一个数组，数组里有5个int类型的元素，
四、 数组参数、指针参数
在写代码时如何把【数组】或者【指针】传给函数呢？
一维数组传参
总结：
一维数组作为实参时，形参可以是一维数组，也可以是指针。
数组指针作为实参时，形参可以是指向一维数组的指针，也可以是二级指针。
二维数组传参
总结：
二维数组作为实参时，形参可以是二维数组，也可以是指针。二维数组作为形参时，不可以省略列；指针作为形参时，必须指向一维数组而不是单个变量。
一级指针传参
void print(int* ptr, int sz)
//一级指针传参，一级指针接收
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d\n", *(ptr + i));
}
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9 };
int* p = arr;//把数组首元素的地址放入指针变量p中
int sz = sizeof(arr) / sizeof(arr[0]);
//一级指针p，传给函数
print(p, sz);
return 0;
}思考：如果形参是一级指针，那实参可以是什么呢？
总结：
一级指针作为实参传过去，形参为一级指针来接收
一级指针作为形参时，实参可以是某个变量的地址，可以是一级指针。
二级指针传参
void test(int** ptr)
//二级指针传过来，二级指针接收
{
printf("num = %d\n", **ptr);
}
int main()
{
int n = 10;
int* p = &n;//p是一级指针
int** pp = &p;//pp是二级指针
test(pp);
return 0;
}思考：如果形参是二级指针，那实参可以是什么呢？
总结：
二级指针作为实参传过去，形参为二级指针来接收。
二级指针作为形参时，实参可以二级指针，可以是一级指针的地址，可以是指针数组。
五、函数指针
首先看一段代码：
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}输出：
test 和 & test 都表示函数的地址。
那如何保存函数的地址呢？
void test()
{
printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();
pfun1可以存放。
pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参
数，返回值类型为void。
()的优先级大于*，pfun2（）表示函数的返回值，*pfun2（）相当于调用函数的返回值，调用一个常量，没有意义。
函数指针：存放函数地址的指针。
练习：
void test(char* str)
{
}将函数的地址取出，放入函数指针变量。
void test(char* str)
{
}
int main()
{
void (*pstr)(char*) = &test;
}三种使用方法皆可，但（*pf）（x，y）中*没有实际的运算意义。
int Add(int x, int y)
{
return (x + y);
}
int main()
{
int x = 2;
int y = 5;
int (*pf)(int,int) = &Add;
int a = Add(x, y);
int b = (*pf)(x, y);
int c = pf(x, y);
printf("%d %d %d", a, b, c);
return 0;
}
阅读两段有趣的代码：
//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);
六、函数指针数组
数组是一个存放相同类型数据的存储空间。
指针数组，是数组中的每个元素都是指针类型，例如：int *arr [10];
那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？
函数指针数组的用途：
转移表
例：计算器
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 meau()
{
printf("************************************\n");
printf("*******1.Add 2.Sub *******\n");
printf("*******3.Mul 4.Div *******\n");
printf("******* 0.exit ********\n");
printf("************************************\n");
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
do
{
meau();
printf("请选择->\n");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入2个操作数\n");
scanf("%d %d", &x, &y);
ret = Add(x, y);
printf("ret=%d\n",ret);
break;
case 2:
printf("请输入2个操作数\n");
scanf("%d %d", &x, &y);
ret = Sub(x, y);
printf("ret=%d\n", ret);
break;
case 3:
printf("请输入2个操作数\n");
scanf("%d %d", &x, &y);
ret = Mul(x, y);
printf("ret=%d\n", ret);
break;
case 4:
printf("请输入2个操作数\n");
scanf("%d %d", &x, &y);
ret = Div(x, y);
printf("ret=%d\n", ret);
break;
case 0:
printf("退出程序\n");
break;
default:
printf("选择错误，重新选择\n");
}
} while (input);
int(*arr[4])(int, int) = { Add,Sub,Mul,Div };
return 0;
}这个代码的缺陷很明显，重复语句很多，太冗杂。
但是如果应用函数指针数组，就会方便很多。
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 meau()
{
printf("************************************\n");
printf("*******1.Add 2.Sub *******\n");
printf("*******3.Mul 4.Div *******\n");
printf("******* 0.exit ********\n");
printf("************************************\n");
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
int(*arr[5])(int, int) = { NULL,Add,Sub,Mul,Div };
do
{
meau();
printf("请选择->\n");
scanf("%d", &input);
if (input >= 1 && input <= 4)
{
printf("请输入2个操作数：\n");
scanf("%d %d", &x, &y);
ret = (arr[input])(x, y);
printf("%d\n", ret);
}
else if (input == 0)
printf("退出程序\n");
else
printf("选择错误,请重新选择\n");
} while (input);
return 0;
}七、指向函数指针数组的指针
指针指向一个数组，数组的元素是函数指针。
void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针
void(*p1)(const char*) = test;
//函数指针数组
void(*p2[5])(const char* str);
p2[0] = test;
//指向函数指针数组的指针
void(*(*p3)[5])(const char*) = &p2;
return 0;
}
八 、回调函数
- 回调函数就是一个通过函数指针调用的函数。
- 如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
- 回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
qsort（快速排序）函数
#include<stdlib.h>
#include<stdio.h>
int cmp(const void* p1, const void* p2)
{
return (*((int*)p1) - *((int*)p2));
}
void print(int* p,int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(p+i));
}
}
int main()
{
int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), cmp);
print(arr, sizeof(arr) / sizeof(arr[0]));
return 0;
}
使用回调函数，模拟实现qsort（采用冒泡的方式）
//数据的比较方式cmp部分由使用者自己决定，此处以int为例
int cmp(const void* p1, const void* p2)
{
return (*((int*)p1) - *((int*)p2));
}
void Swap(char* e1, char* e2,int width)
{
int i = 0;
for (i = 0; i < width; i++)
{
char tmp = *e1;
*e1 = *e2;
*e2 = tmp;
e1++;
e2++;
}
}
void bubble(void* base, int count, int width,int (*cmp)(const void*, const void*))
{
int i = 0;
for (i = 0; i < count-1; i++)//趟数
{
int j = 0;//一趟的排序
for (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] = { 1,3,5,7,9,2,4,6,8,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble(arr, sz, sizeof(arr[0]), cmp);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
九、 指针和数组笔试题解析
1. 一维整型数组与sizeof
2.一维字符数组与sizeof
3.一维字符数组（字符形式）与strlen
4.一维字符数组（字符串形式）与sizeof
5.一维字符数组（字符串形式）与strlen
6.指针与sizeof
7.指针与strlen
8.二维数组与sizeof
十、指针笔试题
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;
//假设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;
}
4.输出的值为多少？
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.输出的值为多少？
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;
} 
对一些函数的补充：
扫一扫
749
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
