【C语言进阶】一文搞懂指针基本操作

云玩家呢

已于 2023-01-19 14:55:22 修改

阅读量535

点赞数 3

分类专栏： C语言进阶文章标签： c++ c语言

于 2023-01-19 14:43:31 首次发布

本文链接：https://blog.youkuaiyun.com/m0_66615785/article/details/128734668

版权

C语言进阶专栏收录该内容

2 篇文章

订阅专栏

本文深入讲解了C语言中的指针概念，包括指针与内存的关系、野指针的产生及避免、指针运算、数组与指针的关联、指针数组、数组指针、函数指针以及函数指针数组。特别讨论了指针在数组和函数中的应用，如回调函数和自定义运算选择。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言：哈喽各位，本文将重点讲解，一维指针，二维指针，指针数组，数组指针，函数指针，函数指针数组等C语言中的重难点，可能会有一些绕

文章目录

- 一、指针

一、指针

1.1指针与内存的概念

内存可以这么理解,为了更好的操作内存空间，将内存空间分为一个一个小格子(内存单元)，每个小格子都有一个对应的地址；
**指针就是变量，用来存放地址的变量；**存放地址的变量成为指针变量；
一个内存单元占用一个字节，一个内存单元的编号(地址)要存放的话，需要的空间大小是4个字节。
指针在32位机器上占用4个字节，64位机器上占用8个字节；

int* p = &a;//指针变量

#include <stdio.h>

int main()
{
    int a = 0x11223344;//定义一个整型变量，存放一个8位16进制的数，2位一个字节，8位正好4个字节；
    int* pa = &a;//整形指针,*p = 0可以访问4个字节的空间，即int a 可以访问这么多位字节0x00000000;
    char* pc = &a;//字符型指针，*p = 0只可以访问1个字节的空间，即int a = 0x11223300;
    printf("%p\n", pa);//发现不同类型指针输出的值都是相同的
    printf("%p\n", pc);
    *p = 0
    return 0;
}

指针类型区别在于指针类型决定了指针解引用操作的时候，能够访问空间的大小(几个字节)

指针类型决定了：指针走一步走多远(指针的步长)

int* p; p+1 -->4字节

char* p; p+1 -->1

double* p; p+1 -->8

1.1.1 指针类型

*const char pa = “abcdefg”；**这是一个常量指针

//字符型指针
int main()
{
    //"abcdefg"是一个常量字符串，可以用const修饰表示指针指向的值不可变const char* pa = "abcdefg"；
    char arr[] = "abcdefg"; //等价于 char* pa = "abcdefg";这里也是把字符串首地址传入指针
    char* pa = arr;//数组名是字符串首地址
    printf("%s\n", arr);//%s是输出一串字符，直到某一个字节内的元素为\0时，输出此字符串并且寻址结束
    printf("%s\n", pa);
    printf("%c\n", *pa);//这样是输出单个字符
    system("pause");
}

void* 类型的指针可以接受任意类型的地址 ; 不可以进行解引用操作；想应用的时候可以进行一个强制类型转换

int a = 10;
void* pa = &a;
*(int*)pa;

1.2 野指针

概念：野指针就是指向的位置是不可知的

产生野指针的几种情况
```
int* p;//局部指针变量未初始化，默认为随机值
```

指针越界访问

int arr[10] = {0};
int *p = arr;
int i =0;
for(i=0,i<12,i++)
{
	*(p++) = i;//当指针指向的范围超出数组arr的范围时，p就是野指针
}

指针指向的空间释放

int* test()
{
	int a = 10;//局部变量，进入他的空间创建，出它的空间销毁，即将这个空间还给操作系统
	return &a;
}
int main()
{
	int* p = test();//确实接收到了地址，但此时这块地址空间已经还给了操作系统，非法访问 
	*p = 20;//使用的时候这块地址的空间已经释放
	return 0;
}

如何避免野指针

指针变量要记得初始化（不知道为指针附一个什么值的时候可以 int p = NULL*）
指针要小心越界
指针指向空间释放后要及时置NULL
指针使用之前检查有效性

1.3 指针的运算

指针 + - 整数

int main()
{
    int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    int *p = arr;
    int i;
    int sz = sizeof(arr) / sizeof(arr[0]);
    for (i = 0; i < sz; i++)
    {
        printf("%d ", *p);//打印数组中全部元素的个数
        p++;

    }
     system("pause");
    return 0;
}

指针 - 指针

int main()
{
    int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    printf("%d", &arr[9] - &arr[0]);//指针减去指针 = 相隔元素的个数
    system("pause");
}

应用：手写strlen函数，求字符串长度

int my_strlen(char* str)
{
    char* start = str;//字符串开始处指针
    char* end = str;//字符串结束处指针
    while (*end != '\0')// '\0'代表字符串结束出标志，为系统自动添加
    {
        end++;
    }
    return end - start;//字符串结束处指针与开始处指针相减，得到字符串元素个数；
}
int main()
{
    char arr[] = "yinjiyuan";
    int len = my_strlen(arr);
    printf("%d", len);
    system("pause");
    return 0;
}

指针的关系运算

#define N_VALUES 5
for(vp = &values[N_VALUES];vp>&values[0];)
{
	*--vp = 0;
}

1.4 数组和指针

1.4.1 指针与数组的关系

数组名就是首元素地址
有两种例外情况如下
1. &arr &数组名数组名不是首元素地址，数组名表示整个数组，&数组名取出的是整个数组的地址
2. sizeof(arr) — sizeof(数组名) 数组名表示整个数组， sizeof(数组名)计算的是整个数组的大小，数组作为参数的时候只传首地址，此时sizeof(数组名) = 4或8(地址占用的字节)

int main()
{
	int arr[10] = {0}；
	printf("%p",arr);//表示的是首元素的地址
    printf("%p",&arr[0]);//表示的是首元素的地址
    printf("%p",&arr);//表示的是整个数组的地址
    /* arr+1增加4个字节；  &arr+1  增加40个字节，因为数组里有10个元素，每个元素4个字节 */
}

p + i 等价于 &arr[i]

int arr[10] = {0}；
int* p = arr;
for(i=0;i<10;i++)
{
	printf("%p  =====   %p", p+i,&arr[i]);//；两者打印的地址完全相同
}

数组可以通过指针来访问

1.4.2 指针数组与数组指针

指针数组 - 数组 - 是一个存放指针的数组

int main()
{
    int a = 10;
    int b = 20;
    int c = 30;
    int i;
    int* arr[3] = {&a, &b, &c};//指针数组
    for (i = 0; i < 3; i++)
    {
        printf("%d  ", *(arr[i]));//对指针数组里的元素进行解应用
    }
    system("pause");
}

指针数组的常规用法

int main()
{
    int arr1[] = {1, 2, 3, 4, 5};
    int arr2[] = {2, 3, 4, 5, 6};
    int arr3[] = {3, 4, 5, 6, 7};

    int *arr[] = {arr1, arr2, arr3};//将三个数组的元素首地址存入指针数组；
    printf("%d",*(arr[1]+2) );//可以通过操作arr指针数组来操作其中任一个数组中的值
    system("pause");
}

数组指针 - 指针 - 存放数组的地址
```
int (*p)[10];//[]的优先级要高于*号，所以必须加上（）来保证p先和*结合；
```
解释：p先和*结合，说明p是一个指针变量，指向的是一个大小为10个整形的数组，所以p是一个指针，指向一个数组，叫数组指针。

数组指针的一般用法

//数组指针的一般用法
void print2(int (*pa)[5], int x, int y) //参数是指针形式，指向的是数组的地址
{
    int i = 0;
    for ( i = 0; i < x; i++)
    {
        int j = 0;
        for ( j = 0; j < y; j++)
        {
            printf("%d", *(*(pa+i)+j) );
            /* 对指针pa进行一次解应用，*pa得到的是一整个一维数组，也就是一维数组首元素的地址 */
            //printf("%d", ( *(pa+i))[j] ); 第二种写法，(pa+i)代表一行的地址，解应用得到这一行再进行操作
        }
        printf("\n");
    }
    
}
int main()
{
    //二维数组的首元素就是{1, 2, 3, 4, 5}
    int arr[3][5] = {{1, 2, 3, 4, 5}, {2, 3, 4, 5, 6}, {3, 4, 5, 6, 7}};
    print2(arr, 3, 5);//数组名就是首元素地址，即{1, 2, 3, 4, 5}的地址；
    system("pause");
}

20230114190306

*(p+i) 等价于p[i]

//parr3是一个数组，这个数组有10个元素，其中的每个元素都是一个数组指针，指向的是一个有5个元素的整型数组

int (*parr3[10])[5]

1.4.3 数组参数与指针参数

一维数组传参

void test(int arr[])
{}
void test(int arr[10])
{}
void test(int *p)
{}
void test2(int* arr[20])
{}
void test2(int **p)
{}
int main()
{
	int arr[10] = {0};
	int* arr2[20] = {0};
	test(arr);
	test2(arr2);//数组名是首元素地址，首元素是一个指针，也就是地址的地址
}

二维数组传参

void test(int arr[3][5])
{}
void test2(int arr[][5])//二维数组行可以省略列不可以省略；
{}
void test3(int (*parr)[5])
{}
int main()
{
    int arr[3][5] = {0};
    test(arr);//把数组当作参数传递，可以直接用数组接收
    test2(arr);
    test3(arr);
    system("pause");
}

一级指针传参

当一个函数的参数部分为一级指针的时候，能接收什么参数

void test1(int *p)
{}
int main()
{
	int a = 10;
	int* p = &a;
	test1(&a);
	teat1(p);
}

二级指针传参

当一个函数的参数部分为二级指针的时候，能接收什么参数

void test1(int **p)
{}
int main()
{
	int a = 10;
	int* pa = &a;
	int** ppa = &pa;
	int* pa[10] = {0};
	
	test1(&pa);//可以接受一级指针的地址
	teat1(ppa);//可以接收二级指针
	test1(pa);//数组指针首元素的地址，就是指针的地址
	
}

1.5 二级指针

指针变量也是变量，是变量就有地址，指针变量存放在哪里呢？存放在二级指针里

int main()
{
    int a = 10;
    int* pa = &a;//pa就是二级指针
    int** ppa = &pa;//ppa就是三级指针
    printf("%d", **ppa);
    system("pause");
}

1.6 函数指针

函数指针 - 就是指向函数的指针 - 存放函数地址的一个指针

//&函数名 与 函数名都是函数的地址
printf("%p\n", Add);
printf("%p\n", &Add);

/函数指针/

int Add(int x,int y)
{
    int z = 0;
    z = x + y;
    return z;
}
int main()
{
    int (*pa)(int, int) = Add;//定义的函数指针，int (*)(int, int)是函数指针类型
    printf("%d", (*pa)(3, 5));
    //此处的*是一个摆设，可以不写(pa)(3, 5)，一样的，因为函数名本身就是函数的地址Add = pa，函数正常是这么用的Add（3，5）
    system("pause");

    return 0;
}

对函数指针类型取一个别名

typedef void(* pfun_t )(int)//等价于给函数指针类型void (*)(int)取一个类型别名 pfun_t

1.6.1 回调函数

概念：回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址)作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
```
//回调函数
void print(char *str) //这是一个回调函数
{
    printf("%s", str);
}
/*另一个函数*/
void test(void (*pa)(char *))
{
    pa("hello");//这个指针被用来调用其所指向的函数时
}
int main()
{
    test(print);//把一个函数的指针作为参数传递给另一个函数
    system("pause");
    return 0;
}
```

1.7 函数指针数组

是一个可以存放函数指针的数组

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 (*parr[4])(int, int) = {Add, Sub, Mul, Div}; //函数指针的数组,存放了4个函数指针
    int i = 0;
    for (i = 0; i < 4; i++)
    {
        printf("%d ", parr[i](2, 3));// i 不同就代表调用不同的函数
    }
    system("pause");
    return 0;
}

函数指针的一般用途

void menu()
{
    printf("***********************************\n");
    printf("****1加                 2减********\n");
    printf("****3乘                 4除********\n");
    printf("**************0退出*****************\n");
}
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 input;
    int x = 0;
    int y = 0;
    int (*pfArr[5])(int, int) = {0, Add, Sub, Mul, Div};//pfArr是一个函数指针数组  -  转移表
    do
    {
        menu();
        printf("请输入你选择的运算");
        scanf("%d", &input);
        if(input >= 1 && input <= 4)
        {
            printf("请输入运算的两位数");
            scanf("%d %d", &x, &y);
            printf("%d\n", pfArr[input](x, y));//通过下标值input 来决定调用哪个函数,可以更为自由的选择使用哪个函数
        }
        else if(input == 0)
        {
            printf("退出\n");
        }
        else
        { 
            printf("请输入正确数字\n");
        }


    } while (input);
    system("pause");
}

1.7.1 指向函数指针数组的指针

int (*pa)(int,int);//函数指针，存放函数的地址
int (*pfArr[4])(int,int);//函数指针的数组，存放函数指针
int (*(*ppfArr)[4])(int,int));// ppfArr是一个指向函数指针数组的指针，指向的数组里有4个元素，每个元素的类型都是int(*) (int,int))型的函数指针