C语言指针进阶

忘是亡心i 2024-03-17 15:58 64阅读 0赞

#### C语言指针进阶 ####

*  一.字符指针
 *  二.指针数组
 *  三.数组指针
 *   *  1.数组名和&数组名
     *  2.数组指针的应用
 *  四.数组及指针传参
 *   *  1.一维数组传参
     *  2.二维数组传参
     *  3.一级指针传参
     *  4.二级指针传参
 *  五.函数指针
 *   *  1.阅读两段有意思的代码
 *  六.函数指针数组
 *  七.指向函数指针数组的指针
 *  八.void\*指针
 *  九.qsort函数
 *  十.自定义qsort函数

## 一.字符指针 ##

在指针的类型中，我们知道有一种类型是char\*，其用法如下

#include <stdio.h>
    int main(){
        
    char s = 'w';
    char* p = &s;
    *p = 'm';
    printf("%c",s);
    }

但是还有另外一种使用方式，如下:

int main()
    {
        
     const char* pstr = "hello bit.";//这里是把一个字符串放到pstr指针变量里了吗？
     printf("%s\n", pstr);
     return 0;
    }

上述const char\* pstr = “hello bit.”;本质上是把，字符串的第一个字符的地址赋给指针变量pstr，用const修饰的原因是直接将字符串赋值给变量，该字符串是一个常量字符串，即字符串的值是不会发生改变的，所以最好用const修饰

## 二.指针数组 ##

指针数组的意思就是有一个数组里面存储元素的类型是指针类型

int* arr1[10]; //整形指针的数组
    char *arr2[4]; //一级字符指针的数组
    char **arr3[5];//二级字符指针的数组

## 三.数组指针 ##

我们来类比一下整形指针，和字符指针  
整形指针: 指向整型变量的指针，存放整型变量的地址的指针变量

字符指针: 指向字符变量的指针，存放字符变量的地址的指针变量

由此我们得到数组指针的定义

数组指针: 指向数组的指针，存放的是数组的地址的指针变量

int *p1[10];//指针数组
    int (*p2)[10];//数组指针

### 1.数组名和&数组名 ###

我们都知道数组名指的是数组的首地址,但有两种特殊情况

> (1) &数组名取得是整个数组的大小，并不是首元素的地址  
> (2)sizeof(数组名)，计算的是整个数组的字节数，并不是首元素的字节数

针对一

#include<stdio.h>
    int main()
    {
        
    	int a[10] = {
         1,2,3,4,5,6,7,8,9,10 };
    	printf("%p\n", a);//数组名就是首元素的地址
    	printf("%p\n", &a[0]);//首元素的地址
    	printf("%p\n", &a);//整个数组的地址
    	printf("%p\n", a + 1);//第二个元素的地址
    	printf("%p\n", &a + 1);//跳过了整个数组
    	printf("%d\n", sizeof(a));//40个字节
    }

![在这里插入图片描述][07891653b99943829d27b2d7b61775bb.png]  
可以看到整个数组的地址和首元素的地址虽然一样但是+1之后完全不同，&a+1跳过了整个数组，a+1则只跳过一个元素

### 2.数组指针的应用 ###

数组指针一般用于二维数组传参

void Print(int(*p)[5],int r,int c)
    {
        
    	for (int i = 0;i < r;i++) {
        
    		for (int j = 0;j < c;j++) {
        
    			printf("%d ", *(*(p + i) + j));
    		}
    		printf("\n");
    	}
    }
    int main()
    {
        
    	int a[3][5] = {
         1,2,3,4,5,4,5,6,7,8,5,6,7,8,9 };
    	Print(a, 3, 5);
    }

所以不管是二维数组还是一维数组，形参都可以用数组或指针的形式

## 四.数组及指针传参 ##

### 1.一维数组传参 ###

#include <stdio.h>
    void test(int arr[])
    {
        }
    void test(int arr[10])
    {
        }
    void test(int *arr)
    {
        }
    void test2(int *arr[20])
    {
        }
    void test2(int **arr)
    {
        }
    int main()
    {
        
     int arr[10] = {
        0};
     int *arr2[20] = {
        0};
     test(arr);
     test2(arr2);
    }

以上都是可以的，切记

指针数组可以拿二级指针接收 因为指针数组中存放的是指针，即地址，并且数组名也是地址，相当于对数组名解引用是数组首元素，数组首元素又是一个地址在解引用才能得到具体的值，所以就是一个二级指针

指针数组只能接收指针数组

### 2.二维数组传参 ###

void test(int arr[3][5])
    void test(int arr[][5])
    void test(int (*arr)[5])

二维数组可以用数组指针接收 这是因为二维数组的数组名是首元素的地址，首元素是一个一维数组，所以数组名就是一维数组的地址，那么自然可以用数组指针访问，访问方式为\*(\*(p+i)+j)

总结:

> (1)一维数组可以用一维数组和一级指针接收  
> (2)指针数组可以用指针数组和二级指针接受  
> (3)二维数组可以用二维数组接收，行可以省略，列不能省略.还可以用数组指针接收

### 3.一级指针传参 ###

#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;
    }

一级指针传参只能拿一级指针接收

### 4.二级指针传参 ###

#include <stdio.h>
    void test(int** ptr)
    {
        
    printf("num = %d\n", **ptr); 
    }
    int main()
    {
        
     int n = 10;
     int*p = &n;
     int **pp = &p;
     test(pp);
     test(&p);
     return 0;
     }

二级指针传参，形参只能拿二级指针接收

## 五.函数指针 ##

函数指针顾名思义是指向函数的指针，函数名就是函数的地址，函数名和&函数名 效果是一样的，都代表函数的地址

书写方式

void (*p)(int,int);

p是一个指针，指针指向一个返回值为空，有两个int型参数的函数

### 1.阅读两段有意思的代码 ###

//代码1
    (*(void (*)())0)();
    //代码2
    void (*signal(int , void(*)(int)))(int);

代码一:调用0地址处的函数

1.  将0强制类型转换为void (\*)() 类型的函数指针
2.  调用0地址处的这个函数 ( \* ( void (\*)() )0 )();

代码二: signal 是一个函数声明

signal 函数有2个参数，第一个参数的类型是int，第二个参数的类型是 void(\*)(int) 函数指针类型

该函数指针指向的函数有一个int类型的参数，返回类型是void  
signal 函数的返回类型也是void(\*)(int) 函数指针类型,该函数指针指向的函数有一个int类型的参数，返回类型是void

代码二的可读性较差，可改为

typedef void(*pf_t)(int);
    pf_t signal(int, pf_t);
    void ( * signal(int, void(*)(int) ) )(int);

用typedef替换函数指针时切记不能这样写typedef void(\*)(int) pf\_t

## 六.函数指针数组 ##

函数指针数组是数组 数组中存放的是一个个函数指针，并且要求这些函数指针所指向的函数的返回值和参数类型要相同

void (*p[4])(int,int);

\[ \]的优先级大于\*，所以p是数组，数组中存的数据类型是void (\*)(int,int);即指向函数的指针，所以叫函数指针数组

#include <stdio.h>
    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(*p[5])(int x, int y) = {
         0, add, sub, mul, div }; //转移表
     while (input)
     {
        
     printf( "*************************\n" );
     printf( " 1:add 2:sub \n" );
     printf( " 3:mul 4:div \n" );
     printf( "*************************\n" );
     printf( "请选择：" );
     scanf( "%d", &input);
     if ((input <= 4 && input >= 1))
     {
        
     printf( "输入操作数：" );
     scanf( "%d %d", &x, &y);
     ret = (*p[input])(x, y);
     }
     else
     printf( "输入有误\n" );
     printf( "ret = %d\n", ret);
     }
     return 0;
    }

## 七.指向函数指针数组的指针 ##

这和上面就有些套娃了,首先这是一个指针，该指针指向的是一个数组，该数组中存放的是指向函数的指针  
写法如下

void (*(*p)[4])(int,int) = &Add;

## 八.void\*指针 ##

void\*是一种通用类型(无具体类型)指针  
他可以接受任意类型的地址，但不能进行解引用操作，也不能直接进行指针运算

## 九.qsort函数 ##

参数  
void qsort(  
void\* base 指向了需要排序的数组的第一个元素  
size\_t num 排序的元素个数  
size\_t size 一个元素的大小(单位是字节)  
int (\*cmp)(const void \*,const void \*) 函数指针类型，这个函数指针所指向的函数要能够比较数组中元素的大小  
)

头文件  
include <stdlib.h>

qsort的使用

int cmp_int(const void* p1,const void* p2)
    {
        
    	return (*(int*)p2 - *(int*)p1);
    }
    void print(int a[],int sz)
    {
        
    	for (int i = 0;i < sz;i++)
    	{
        
    		printf("%d ", a[i]);
    	}
    }
    test1()
    {
        
    	int arr[10] = {
         9,8,7,6,0,4,3,2,1,10 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	qsort(arr, sz, sizeof(arr[0]), cmp_int);
    	print(arr, sz);
    }
    int main()
    {
        
    	test1();
    }

## 十.自定义qsort函数 ##

void print(int a[],int sz)
    {
        
    	for (int i = 0;i < sz;i++)
    	{
        
    		printf("%d ", a[i]);
    	}
    }
    void swap(char* buf1,char* buf2,int size)
    {
        
    	char temp = 0;
    	for (int i = 0;i < size;i++)
    	{
        
    		temp = *buf1;
    		*buf1 = *buf2;
    		*buf2 = temp;
    		buf1++;
    		buf2++;
    
    	}
    }
    void Bubble_sort(void* p,int num,int size,int(*cmp)(const void*,const void*))
    {
        
    	for (int i = 0;i < num - 1;i++)
    	{
        
    		for (int j = 0;j < num - i - 1;j++)
    		{
        
    			if (cmp((char*)p+j*size,(char*)p+(j+1)*size) >0)
    			{
        
    				swap((char*)p + j * size, (char*)p + (j + 1) * size,size);
    			}
    		}
    	}
    }
    int cmp(const void* p1, const void* p2)
    {
        
    	return(*(int*)p1 - *(int*)p2);
    }
    void test()
    {
        
    	int arr[10] = {
         9,8,7,6,0,4,3,2,1,10 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	Bubble_sort(arr, sz, sizeof(arr[0]), cmp);
    	print(arr, sz);
    }
    int main()
    {
        
    	test();
    }

[07891653b99943829d27b2d7b61775bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/22fefc8e63934a4b8475f04a0ec425a5.png