C语言—指针进阶（详解）
大家好，我是Abert，这篇文章跟大家分享指针的高阶内容。众所周知，指针堪称C语言的灵魂，掌握指针是学好C语言的关键。
这篇文章建立在上篇（初阶指针)文章的基础上进行的，建议大家配合上篇文章一起食用效果更佳。
文章目录
1.指针数组
1.1字符指针数组
1.2整形指针数组
2.数组指针
3.函数指针
4.函数指针数组
5.结构体指针
6.指针进阶题目
正文
1.指针数组
指针数组是数组，数组内存放的是指针
1.1字符指针数组
存放字符指针的数组
char* arr[];//存放字符的地址（指针）1.2整形指针数组
存放整形指针的数组
#include
int main()
{
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int* arr[] = { &a, &b, &c, &d };//整形指针数组
//存放整形的地址（指针）
return 0;
} 2.数组指针
数组指针是指针，存放数组的地址。
#include
int main()
{
int arr[10] = { 0 };
int (*p)[10] = &arr;//数组指针，存放整形数组arr的地址
return 0;
} 数组指针与指针数组容易混淆
int arr[5];
arr是一个数组，每个元素是int类型的 ，有5个元素
int* parr1[10];
parr1是一个数组，数组10个元素，每个元素的类型是int*
int (*parr2)[10];
parr2是一个指向数组的指针，指向的数组有10个元素，每个元素的类型是int
int(* parr3[10])[5];
parr3是一个数组，数组有10个元素，每个元素的类型是：int(*)[5]
parr3是存放数组指针的数组
用指针打印数组
#include
void test(int* ptr, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *ptr);
ptr++;
}
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;//数组首元素的地址
int sz = sizeof(arr) / sizeof(arr[0]);
test(p, sz);
return 0;
} 二维数组的指针问题
#include
void test1()
{
}
void test2()
{
*p;
}
int main()
{
int arr[3][5];
test1(arr);//传递的数组第一行的地址
test2(&arr);//传递的是整个二维数组的地址
return 0;
} 3.函数指针
函数指针是指向函数的指针
int test(char* str)
{
}
int Add(int x, int y)
{
return x + y;
}
int main()
{
printf("%p\n", &Add);//
printf("%p\n", Add);//结果相同
int (*pf)(int, int) = Add;//函数指针变量
int ret = Add(2, 3);//
int num = pf(2, 3);//上下结果相同
printf("%d", ret);
int (*pt)(char*) = test;
return 0;
}
int main()
{
// void (*)()是函数指针类型
// void (*p)()
// ( void (*)() ) 强制类型转换
// （类型）
//（ void(*)() ）0 对0进行强制类型的转换
//（ *（ void (*)() ）0 ）();
// 1. 首先是把0强制类型转换为一个函数指针类型，这就意味着0地址处放一个返回类型是void，无参的一个函数
// 2. 调用0地址处的这个函数
//
//函数声明
//int Add(int, int);
//
//void (* signal(int , void(*)(int)) )(int);//函数声明
//typedef void(* pf_t)(int);//给函数指针类型void(*)(int)重新起名叫：pf_t
//pf_t siganl(int, pf_t);
//signal是一个函数的声明
//signal函数的参数，第一个是int 类型的，第二个是void(*)(int)的函数指针类型
//signal函数返回的值的类型也是：void(*)(int)的函数指针
//
//void(*)(int) siganl(int , void(*)(int));//err 错误
return 0;
}4.函数指针数组
函数指针数组是数组，存放函数指针
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[4])(int, int) = { Add, Sub, Mul, Div };//存放函数指针地址
int i = 0;
for (i = 0; i < 4; i++)
{
int ret = pf[i](2, 3);
printf("%d\n", ret);
}
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 menu()
{
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
{
menu();
printf("请选择->:");
scanf("%d", &input);
switch (input)
{
case 0:
printf("退出计算器。\n");
break;
case 1:// 加
printf("请输入两个操作数：>");
scanf("%d %d", &x, &y);
ret = Add(x, y);
break;
case 2://减
printf("请输入两个操作数：>");
scanf("%d %d", &x, &y);
ret = Sub(x, y);
break;
case 3://乘
printf("请输入两个操作数：->");
scanf("%d %d", &x, &y);
ret = Mul(x, y);
break;
case 4://除
printf("请输入两个操作数：->");
scanf("%d %d", &x, &y);
ret = Div(x, y);
break;
default:
printf("选择错误\n");
break;
}
} while (input);
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 menu()
{
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(*pfArr[])(int, int) = { 0,Add,Sub,Mul,Div };//函数指针数组
do
{
menu();
printf("请选择：>");
scanf("%d", &input);
if (input == 0)
{
printf("退出计算器\n");
}
else if (input >= 1 && input <= 4)
{
printf("请输入两个操作数：->");
scanf("%d %d", &x, &y);
ret = pfArr[input](x, y);//通过函数指针数组调用函数
printf("ret = %d\n", ret);
}
else
{
printf("选择错误\n");
}
} while (input);
return 0;
}主函数内部代码明显改善
比较大型的工程使用函数指针数组可以让效率提升很多
5.结构体指针
结构体指针——存放结构体的地址
struct Stu
{
char name[20];//学生的姓名
int age;//学生的年龄
}ss;
typedef struct Stu STU;//结构体重命名为Stu
int main()
{
STU* str;//定义结构体指针
str = &ss;
//若结构体为数组
//STU stu[5];
//STU* p;
//*p = stu;//stu为结构体数组，p指向stu的首元素地址
return 0;
}利用结构体指针访问结构体变量成员有以下两种方式
(*p).name (name是结构体中的变量名称)
p->name
以下方式的效果是相同的
(*p).name;
p->name;
ss.name指向结构体数组的指针
struct Student stu1[5];
struct Student* p;
p = stu[n];//n代表访问结构体数组的第n个元素，n是常量
6.指针进阶题目
到这里我们对指针有了大概的了解，下面通过一些题目巩固我们对指针的理解
int main()
{
int a[] = { 1,2,3,4 };
0 1 2 3
int (*p)[4] = &a;
printf("%d\n", sizeof(a));//4*4 = 16
printf("%d\n", sizeof(a + 0));//4/8 a+0是数组第一个元素的地址，是地址，大小就是4/8个字节
printf("%d\n", sizeof(*a)); //4 a表示数组首元素的地址，*a表示数组的第一个元素，sizeof(*a)就是第一个元素的大小-4
printf("%d\n", sizeof(a + 1));//4/8 a表示数组首元素的地址，a+1数组第二个元素的地址，sizeof(a+1)就是第二个元素的地址的大小
printf("%d\n", sizeof(a[1]));//4 计算的是第二个元素的大小
printf("%d\n", sizeof(&a));//4/8 &a取出的是数组的地址，数组的地址也是地址呀，是地址大小就是4/8字节
printf("%d\n", sizeof(*&a));//16 计算的整个数组的大小
printf("%d\n", sizeof(&a + 1));//4/8 - &a是数组的地址，+1跳过整个数组，产生的4后边位置的地址
printf("%d\n", sizeof(&a[0]));//4/8 取出的数组第一个元素的地址
printf("%d\n", sizeof(&a[0] + 1));//4/8 数组第二个元素的地址
字符数组
char arr[] = { 'a','b','c','d','e','f' };//[a b c d e f]
printf("%d\n", strlen(arr));//随机值，arr数组中没有\0，所以strlen函数会继续往后找\0，统计\0之前出现的字符个数
printf("%d\n", strlen(arr + 0));//随机值，arr+0还是数组首元素的地址
printf("%d\n", strlen(*arr));//err - arr是数组首元素的地址，*arr是数组的首元素，‘a’-97
printf("%d\n", strlen(arr[1]));//err -'b' - 98
printf("%d\n", strlen(&arr));//随机值
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//随机值
printf("%llu\n", sizeof(arr));//6
printf("%llu\n", sizeof(arr + 0));//4/8 arr + 0是数组首元素的地址
printf("%llu\n", sizeof(*arr));//1 - *arr是首元素，首元素是一个字符，大小是一个字节
printf("%llu\n", sizeof(arr[1]));//1 - arr[1]是数组的第二个元素，大小是1个字节
printf("%llu\n", sizeof(&arr));//4/8 &arr是数组的地址
printf("%llu\n", sizeof(&arr + 1));//4/8 &arr + 1是从数组地址开始向后跳过了整个数组产生的一个地址
printf("%llu\n", sizeof(&arr[0] + 1));//4/8 &arr[0] + 1 是数组第二个元素的地址
return 0;
}
//sizeof是一个操作符
//sizeof 计算的是对象所占内存的大小-单位是字节,size_t
//不在乎内存中存放的是什么，只在乎内存大小
//
//strlen 库函数
//求字符串长度，从给定的地址向后访问字符，统计\0之前出现的字符个数
int main()
{
char arr[] = { 'a', 'b', 'c','d', 'e', 'f' };
char arr[] = "abcdef";
//[a b c d e f \0]
printf("%d\n", strlen(arr));//6
printf("%d\n", strlen(arr + 0));//6
//printf("%d\n", strlen(*arr));//err
//printf("%d\n", strlen(arr[1]));//err
printf("%d\n", strlen(&arr));//6
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//5
printf("%d\n", sizeof(arr));//7
printf("%d\n", sizeof(arr + 0));//4/8 arr+0是数组首元素的地址
printf("%d\n", sizeof(*arr));//1 - *arr 数组的首元素
printf("%d\n", sizeof(arr[1]));//1 arr[1]数组的第二个元素
printf("%d\n", sizeof(&arr));//4/8 - &arr数组的地址，但是数组的地址依然是地址，是地址大小就是4/8
printf("%d\n", sizeof(&arr + 1));//4/8 - &arr + 1是\0后边的这个地址
printf("%d\n", sizeof(&arr[0] + 1));//4/8 - &arr[0] + 1是数组第二个元素的地址
char* p = "abcdef";
printf("%d\n", strlen(p));//6
printf("%d\n", strlen(p + 1));//5 从b的位置开始向后数字符
//printf("%d\n", strlen(*p)); //err
//printf("%d\n", strlen(p[0]));//err
printf("%d\n", strlen(&p));//随机值
printf("%d\n", strlen(&p + 1));//随机值
printf("%d\n", strlen(&p[0] + 1));//5 从b的位置开始向后数字符
printf("%d\n", sizeof(p));//4/8 p是指针变量，计算的是指针变量的大小
printf("%d\n", sizeof(p + 1));//4/8 p+1是'b'的地址
printf("%d\n", sizeof(*p)); //1 - *p 其实就是'a'
printf("%d\n", sizeof(p[0]));//1 - p[0]-> *(p+0)-> *p
printf("%d\n", sizeof(&p));//4/8 &p 是指针变量p在内存中的地址
printf("%d\n", sizeof(&p + 1));//4/8 - &p+1是跳过p之后的地址
printf("%d\n", sizeof(&p[0] + 1));//4/8 &p[0]是‘a’的地址，&p[0]+1就是b的地址
//二维数组
int a[3][4] = { 0 };
printf("%d\n", sizeof(a));//计算的是整个数组的大小，单位是字节3*4*4 = 48
printf("%d\n", sizeof(a[0][0]));//4 第1行第一个元素的大小
printf("%d\n", sizeof(a[0]));//16 - a[0]是第一行的数组名，sizeof(a[0])就是第一行的数组名单独放在sizeof内部，计算的是第一行的大小
printf("%d\n", sizeof(a[0] + 1));//4/8 a[0]作为第一行的数组名，并没有单独放在sizeof内部，也没有被取地址
//所以a[0]就是数组首元素的地址，就是第一行第一个元素的地址，a[0]+1就是第一行第二个元素的地址
printf("%d\n", sizeof(*(a[0] + 1)));//4 - *(a[0] + 1))表示的是第一行第二个元素
printf("%d\n", sizeof(a + 1));//4/8 - a表示首元素的地址，a是二维数组，首元素的地址就是第一行的地址
//所以a表示的是二维数组第一行的地址，a+1就是第二行的地址
printf("%d\n", sizeof(*(a + 1)));//16 对第二行的地址解引用访问到就是第二行
//*(a+1) -> a[1]
//sizeof(a[1])
//
printf("%d\n", sizeof(&a[0] + 1));//4/8 - a[0]是第一行的数组名，&a[0]取出的就是第一行的地址
//&a[0] + 1 就是第二行的地址
printf("%d\n", sizeof(*(&a[0] + 1)));//16 - 对第二行的地址解引用访问到就是第二行
printf("%d\n", sizeof(*a));//16 - a就是首元素的地址，就是第一行的地址，*a就是第一行
//*a - > *(a+0) -> a[0]
printf("%d\n", sizeof(a[3]));//16 int [4]
int a = 10;
printf("%d\n", sizeof(a));//4
printf("%d\n", sizeof(int));//4
return 0;
}总结
以上就是这篇文章的全部内容，指针是C语言最奇妙的部分之一，可以通过指针完成很多操作并提升整体工作效率，欢迎大家学习交流。