【C语言】指针知识全总结

大家好，欢迎来到IT知识分享网。

一.指针是什么

int a=10; int *ptr; ptr=&a; *ptr=5; 

int* ptr;表示声明一个指针变量ptr用于存储某个整数变量的指针（即地址）。
*在这里表示声明的变量是一个指针。
int表示指针所指向的类型。
ptr=&a表示ptr指向变量a,存储a的地址。 &(地址运算符)用于取出变量的地址
*ptr=5;*(解引用操作符)后跟一个指针名或地址时，*给出存储在指针指向地址的值。这里表示将5赋值给该指针所指向的变量。

指针其实是地址，但平常我们说指针指的是指针变量

二.指针类型

1.指针类型决定了指针在解引用时访问几个字节

2.指针类型决定指针+1或-1时跳过几个字节

详见指针运算

三.指针所指向的类型

我们可以将声明部分的指针变量名去掉来观察指针指向何类型
例如

char* p = "abcde";//char* 指向char类型变量的指针 int** p2=&p1;//int* 指向指针的指针，二级指针 int* parr[3] = { 
    arr1,arr2,arr3 };//int* [] 指向整数的指针数组 int (*p2)[5] = &arr;//int (*)[] 指向整数的数组指针 

四.指针与数组

int*p=arr
下述左侧等价于右侧

&arr[i] <==> p+i
arr[i] <==>*(p+i)
arr[i] <==>*(arr+i)

五.指针数组

指针数组指存放指针的数组

int* arr[5]声明一个存放五个指针的数组
char* ch[5]声明一个存放字符指针的数组
char arr[5]声明一个存放二级字符指针的数组

我们可以使用指针数组实现二维数组

 int arr1[] = { 
    1,2,3,4,5 }; int arr2[] = { 
    2,3,4,5,6 }; int arr3[] = { 
    3,4,5,6,7 }; int* parr[3] = { 
    arr1,arr2,arr3 }; //声明一个指针数组，取一维数组地址。 for (int i = 0; i < 3; i++) { 
    int j = 0; for (j = 0; j < 5; j++) { 
    printf("%d ", *(parr[i] + j));//等价于parr[i][j] } printf("\n"); } 

可以实现二维数组的功能，并且这三个数组在内存上不连续。

六. 指针的算术运算

1.指针与整数相加

指针与整数相加，整数都会和指针指向类型大小（以字节为单位）相乘，然后把结果与初始地址相加。

int main() { 
    int arr[5] = { 
    1,2,3,4,5 }; int* p = arr; printf("%d ", *p);//1 printf("%d ", *(p+1));//2 } 

下图可观察到p与p+1地址相差4，也就是指针指向int类型的大小

因此*(p+1)相当于arr[2]

2.指针与整数相减

3.指针与指针相加

指针与指针相加没有意义，就像没人会把日期与日期相加。

4.指针与指针相减

指针求差的两个指针分别指向数组的不同元素，计算出两元素间距离，差值单位与数组类型单位相同。

int main() { 
    int arr[5] = { 
    1,2,3,4,5 }; int* p1 = &arr[4]; int* p2 = &arr[2]; printf("%d ", p1-p2);//2 } 

这里得到的2是指数组第三个元素与第五个元素直接相差2个int类型大小的字节，即8字节。

5.数组与整数相加

注意 ：数组名通常表示首元素地址，但有以下两种例外：
1.sizeof(数组名) 中表示整个数组，因此得出的使整个数组的大小；
2.&数组名 也表示整个数组。


对第二种情况做出解释，请看如下代码：

 int arr[5] = { 
    0,1,2,3,4 }; printf("%p\n", arr); printf("%p\n", arr+1); printf("%p\n", &arr[0] ); printf("%p\n", &arr[0] + 1); printf("%p\n", &arr); printf("%p\n", &arr+1); 

第一组与第二组等价，都表示数组的首元素，加1，地址加4个字节；但第三组&arr表示整个数组的地址，加1，表示该数组首元素与整个数组大小相加，在内存上有68变为7c，共20个字节。

七.野指针

野指针产生的原因

避免野指针的方法

1.使用空指针时判断是否为空指针；

if (p != NULL) { 
   *p = 100;} 

八.二级指针

二级指针是存放一级指针变量指针的地址

int main() { 
    int a = 10; int* pa = &a; int** ppa = &pa; } 

int ppa = &pa要理解这段代码可以使用上文的方法，先看看ppa指向的类型，去掉指针变量名得到int* =&pa，可以看到，ppa指向一个int*类型的变量，即pa的指针。

九.const与指针

const int *ptr与int* const ptr
const int *ptr1.ptr值可变，即可以让ptr指向其他变量；2.不可通过ptr修改其所指向数据的值
int* const ptr1.ptr值不可变，不能让ptr指向其他变量；2.但可通过ptr修改其所指向对象的值
笔者总结如下
远离随意指向，原对象值不变；靠近指向唯一，原对象值可变
需注意原对象值可变与否指的是是否能用const修饰的指针来更改原对象的值。

十.字符指针

char* p="hello"; printf("%S",p);//hello printf("%c",*p);//h 

这里的p是该字符数组的首元素地址,实际上是通过字符指针访问该字符串。

十一.数组指针

数组指针指的是数组名的指针，即数组首元素地址的指针。

int (*p)[10] p即为指向数组的指针，又称数组指针。

int main() { 
    int arr[5] = { 
    0 }; int(*p)[5] = &arr; } 

[]优先级高于*，所以给*加上括号。
p指向一个内含五个Int类型值的数组。

分析如下示例:

int arr[] = { 
    1,2,3,4,5,6,7,8,9,10 }; int(*p1)[10] = &arr; for(int i=0;i<10;i++) { 
    printf("%d ", *(*p1 + i)); } 

p1为&arr
*p1为arr,
*p1 + i为数组首元素地址加i乘int类型大小字节得到的地址
*(*p1 + i)相当于*(arr+i)相当于arr[i]

分析如下二维数组

int main() { 
    int arr[3][4] = { 
    1,2,3,4,2,3,4,5,3,4,5,6 }; int(*p)[4] = &arr; printf("%p %p\n", p, p + 1); printf("%p %p\n", p[0], p[0] + 1); } 

可以发现 p, p + 1相差16字节，p[0], p[0] + 1相差4字节。
因此可知虽然数组指针的地址是数组首元素地址，但实际上指的是二维数组第一行首元素的地址，所以跨越了一行4个int类型的元素也就是16字节。
观察如下二维数组

void print(int(*p)[5], int row, int cow) { 
    int i = 0; int j = 0; for (i = 0; i < row; i++) { 
    for (j = 0; j < cow; j++) { 
    printf("%d ", *((*p+i)+j) ); } printf("\n"); } } int main() { 
    int arr[3][5] = { 
    1,2,3,4,5,2,3,4,5,6,3,4,5,6,7, }; print(arr, 3, 5); } 

*((*p+i)+j) 相当于arr[i][j]
*p+i找到行
*(()+j) 找到列

十二.数组参数，指针参数

test(int arr[]) test(int* arr) test(int arr[10]) int main() { 
    int arr[10] = { 
    0 }; test(arr); } 

对于一维数组上述三种均可

test(int arr[][4]) test(int arr[3][4]) test(int(*p)[4]) int main() { 
    int arr[3][4] = { 
   0}; test(arr); } 

十三.函数指针

函数指针是指指向函数的指针

&函数名和函数名都指函数的地址

int ADD(int x, int y) { 
    return x + y; } int main() { 
    printf("%p\n", ADD); printf("%p\n", &ADD); } 

观察如下代码

int ADD(int x, int y) { 
    return x + y; } int main() { 
    int (*pf)(int, int) = &ADD; printf("%p\n", &ADD); //int ret = (*pf)(2, 3); int ret = pf(2, 3); printf("%d\n", ret); } 

一个加法函数，需要两个int类型变量，返回类型为int，可以声明其指针为int (*pf)(int, int) = &ADD;分别表示返回类型，*指针名，函数各参数类型
int ret = (*pf)(2, 3); 等价于int ret = pf(2, 3);，可以不加*。
那么什么情况下要使用函数指针呢

int ADD(int x, int y) { 
    return x + y; } void calc(int(*pf)(int, int)) { 
    int a = 3; int b = 5; int ret = pf(a, b); printf("%d\n", ret); } int main() { 
    calc(ADD); return 0; } 

在main函数中，调用了calc函数，并将ADD函数作为参数传递给它。这样，calc函数内部就能够使用ADD函数。我们可以将函数作为参数（也就是函数的地址）传递给其他函数，从而能够在calc函数中使用ADD函数。

十四.函数指针数组

存放函数指针的数组

需注意所存放的函数格式应相同，也就是说传入参数个数类型，返回类型都应相同。

#include<stdio.h> int add(int a, int b) { 
    return a + b; } int subtract(int a, int b) { 
    return a - b; } int multiply(int a, int b) { 
    return a * b; } int divide(int a, int b) { 
    return a / b; } int main() { 
    int (*arr[4])(int, int) = { 
    add ,subtract ,multiply ,divide };//函数指针的数组 int i = 0; for (i = 0; i < 4; i++) { 
    int ret = arr[i](8, 4); printf("%d ", ret); } } 

来看主函数，声明一个函数指针的数组，声明方法与函数指针类似，但需在函数明后加上[]来表明为数组指针，分别放入加减乘除四个函数的函数名。

函数指针数组有何用呢

看一个经典的实现计算器功能的代码

#include <stdio.h> int add(int a, int b) { 
    return a + b; } int subtract(int a, int b) { 
    return a - b; } int multiply(int a, int b) { 
    return a * b; } int divide(int a, int b) { 
    return a / b; } void menu() { 
    printf("*\n"); printf("* 1.add 2.subtract *\n"); printf("* 3.multiply 4.divide *\n"); printf("* 0.exit *\n"); printf("*\n"); } int main() { 
    int input = 0; int a = 0; int b = 0; int ret = 0; int (*arr[5])(int, int) = { 
    0,add ,subtract ,multiply ,divide }; do { 
    menu(); printf("请输入:>"); scanf("%d", &input); if(input>0 && input<=4) { 
    printf("请输入两数:>"); scanf("%d %d", &a, &b); int ret = arr[input](a, b); printf("结果为:>%d\n", ret); } else if (input == 0) { 
    printf("退出计算器\n"); break; } else { 
    printf("选择错误\n"); } } while (input); return 0; } 

指向函数数组指针的指针

int (*parr[5])(int, int) = { 
    0,add ,subtract ,multiply ,divide }; int (*(*pparr[5]))(int, int) = &parr; 

根据找指针指向类型的方法，去掉指针名，可发现int (*(*[5]))(int, int) = &parr;指向函数指针数组。

后续内容笔者仍在学习，文章如有错误望您指正。

感谢您的阅读