C语言-指针进阶

拼搏现实的明天。 2024-03-17 21:28 104阅读 0赞

**目录**

一、字符指针

二、指针数组

三、数组指针

3.1 数组指针的定义

3.2 数组名和&数组名

3.3 数组指针的使用

四、数组参数、指针参数

4.1 一维数组传参

4.2 二维数组传参

4.3 一级指针传参

4.4二级指针传参

五、函数指针

六、函数指针数组

七、指向函数指针数组的指针

八、回调函数

九、指针和数组笔试题

9.1 一维数组

9.2 字符数组

9.3 二维数组

--------------------

## 一、字符指针 ##

在指针类型中有一种指针类型为字符指针 char\* ;

使用

> int  main () 
> 
> \{ 
> 
>  char  ch  =  'w' ; 
> 
>  char \* pc  = & ch ; 
> 
>  \* pc  =  'w' ; 
> 
>  return  0 ; 
> 
> \}

> int  main () 
> 
> \{ 
> 
> const  char\*  pstr  =  "hello bit." ; //把一个字符串首字符h的地址放到pstr指针变量中
> 
> printf ( "%s\\n" ,  pstr ); 
> 
> return  0 ; 
> 
> \}

## 二、指针数组 ##

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

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

## 三、数组指针 ##

### 3.1 数组指针的定义 ###

整形指针： int \* pint; 指向整形数据的指针。

浮点型指针： float \* pf; 指向浮点型数据的指针。

数组指针应该是：指向数组的指针或存放数组地址的指针变量。形如 int (\* p1 ) \[ 10 \];

### 3.2 数组名和&数组名 ###

> int arr\[10\];

arr是数组名，也是数组首元素的地址，而&arr是数组的地址，不是首元素的地址。arr+1是数组中相应的下一个元素，&arr+1是数组的地址+1，跳过整个数组的大小。

### 3.3 数组指针的使用 ###

数组指针中存放的是数组的地址，多用于二维数组。

> <stdio.h> 
> 
> void  print\_arr1 ( int  arr \[ 3 \]\[ 5 \],  int  row ,  int  col ) 
> 
> \{ 
> 
>  int  i  =  0 ; 
> 
>  for ( i = 0 ;  i < row ;  i \++ ) 
> 
>  \{ 
> 
>  for ( j = 0 ;  j < col ;  j \++ ) 
> 
>  \{ 
> 
>  printf ( "%d " ,  arr \[ i \]\[ j \]); 
> 
>  \} 
> 
>  printf ( "\\n" ); 
> 
>  \} 
> 
> void  print\_arr2 ( int  ( \* arr )\[ 5 \],  int  row ,  int  col ) 
> 
> \{ 
> 
>  int  i  =  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 \}; 
> 
>  print\_arr1 ( arr ,  3 ,  5 ); 
> 
>  //数组名arr，表示首元素的地址，但是二维数组的首元素是二维数组的第一行
> 
>  //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址 
> 
>  //可以数组指针来接收 
> 
>  print\_arr2 ( arr ,  3 ,  5 ); 
> 
>  return  0 ; 
> 
> \}

## 四、数组参数、指针参数 ##

数组参数或指针参数是将数组或指针传递给函数。

### 4.1 一维数组传参 ###

一维数组传参，形参可以是数组，也可以是指针。

> void test1(int arr\[5\], int sz)
> 
> \{\}
> 
> void test2(int\* p, int sz)
> 
> \{\}
> 
> int main()
> 
> \{
> 
> int arr\[5\] = \{ 0 \};
> 
> test1(arr, 5);
> 
> test2(arr, 5);
> 
> return 0;
> 
> \}

### 4.2 二维数组传参 ###

二维数组传参，形参的部分可以是数组，也可以是指针。

> void test3(char arr\[3\]\[5\], int r, int c)
> 
> \{\}
> 
> void test4(char (\*p)\[5\], int r, int c)
> 
> \{\}
> 
> int main()
> 
> \{
> 
> char arr\[3\]\[5\] = \{0\};
> 
> test3(arr, 3, 5);
> 
> test4(arr, 3, 5);
> 
> return 0;
> 
> \}

注意：二维数组传参，形参中行可以省略，列不可以省略，可以传递一级指针的数组指针 int(\*arr)\[5\]，不能传递一级指针数组int \*arr\[5\]，不能传递二 级指针int \*\* arr。

### 4.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 \}; 
> 
>  int \* p  =  arr ; 
> 
>  int  sz  =  sizeof ( arr ) / sizeof ( arr \[ 0 \]); 
> 
>  //一级指针p，传给函数 
> 
>  print ( p ,  sz ); 
> 
>  return  0 ; 
> 
>  \}

### 4.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 ; 
> 
> \}

## 五、函数指针 ##

> \#include <stdio.h> 
> 
> void  test () 
> 
> \{ 
> 
>  printf ( "helloe\\n" ); 
> 
> \} 
> 
> int  main () 
> 
> \{ 
> 
>  printf ( "%p\\n" ,  test ); 
> 
>  printf ( "%p\\n" ,  & test ); 
> 
>  return  0 ; 
> 
> \}

输出结果为：

![880f7f1dbd7d492092a22635ee2a4ced.png][]

若要保存函数的地址，需用指针

> void (\*pfun1)();

pfun1先和\*结合，则pfun1是指针，指针指向一个函数，指向的函数无参数，返回值类型 为void。

## 六、函数指针数组 ##

函数指针数组：把函数的地址存到一个数组中。

> int (\*parr1\[10\])();

parr1 先和 \[\] 结合，parr1是数组，数组的内容是 int (\*)() 类型的函数指针。函数指针数组的用途：**转移表。**

常规调用函数实现简易计算器

#include <stdio.h>
    #include <string.h>
    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("****5 Exit        ****\n");
    	printf("**********************\n");
    }
    
    int main()
    {
    	int x = 0, y = 0, input = 0,ret=0;
    	do
    	{
    		menu();
    		printf("请输入：");
    		scanf("%d", &input);
    		switch (input)
    		{
    			case 1:
    				printf("请输入两个数：");//有冗余
    				scanf("%d%d", &x, &y);
    				ret=Add(x, y);
    				printf("%d\n", ret);
    				break;
    			case 2:
    				printf("请输入两个数：");
    				scanf("%d%d", &x, &y);
    				ret = Sub(x, y);
    				printf("%d\n", ret);
    				break;
    			case 3:
    				printf("请输入两个数：");
    				scanf("%d%d", &x, &y);
    				ret = Mul(x, y);
    				printf("%d\n", ret);
    				break;
    			case 4:
    				printf("请输入两个数：");
    				scanf("%d%d", &x, &y);
    				ret = Div(x, y);
    				printf("%d\n", ret);
    				break;
    			case 5:
    				printf("退出计算器\n");
    				break;
    			default:
    				printf("输入数字无效，请重新输入\n");
    				break;
    		}
    	} while (input);
    	return 0;
    }

用函数指针实现简易计算器

#include <stdio.h>
    #include <string.h>
    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("****5 Exit        ****\n");
    	printf("**********************\n");
    }
    int main()
    {	
    	int x = 0, y = 0, input = 0, ret = 0;
    	do
    	{
    		menu();
    		printf("请输入：");
    		scanf("%d", &input);
    		printf("请输入两个整数：");
    		scanf("%d%d",& x, &y);
    		int(*pf[5])(int, int) = { NULL,Add,Sub,Mul,Div };//转移表
    		if (input >= 1 && input <= 4)
    		{
    			ret = pf[input](x, y);
    			printf("%d\n", ret);
    		}
    		else if (input == 5)
    			printf("退出计算机");
    		else
    			printf("输入数字无效，请重新输入：\n");
    	} while (input);
    	return 0;
    }

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

指向函数指针数组的指针：是一个指针指向一个数组 ，数组的元素都是函数指针。

> void  test ( const  char\*  str ) 
> 
> \{ 
> 
>  printf ( "%s\\n" ,  str ); 
> 
> \} 
> 
> int  main () 
> 
> \{ 
> 
>  // 函数指针 pfun 
> 
>  void  ( \* pfun )( const  char\* )  =  test ; 
> 
>  // 函数指针的数组 pfunArr 
> 
>  void  ( \* pfunArr \[ 5 \])( const  char\*  str ); 
> 
>  pfunArr \[ 0 \]  =  test ; 
> 
>  // 指向函数指针数组 pfunArr 的指针 ppfunArr 
> 
>  void  ( \* ( \* ppfunArr )\[ 5 \])( const  char\* )  = & pfunArr ; 
> 
>  return  0 ; 
> 
> \}

## 八、回调函数 ##

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给 另一个函数，当 这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调 用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

用回调函数实现简易计算器

#include <stdio.h>
    #include <string.h>
    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("****5 Exit        ****\n");
    	printf("**********************\n");
    }
    void Cala(int(*p)(int, int))//回调函数
    {
    	int x = 0, y = 0, ret = 0;
    	printf("请输入两个数：");
    	scanf("%d %d", &x, &y);
    	ret = p(x, y);
    	printf("%d\n", ret);
    }
    int main()
    {
    	int x = 0, y = 0, input = 0, ret = 0;
    	do
    	{
    			menu();
    			printf("请输入：");
    			scanf("%d", &input);
    			switch (input)
    			{
    				case 1:
    						Cala(Add);
    						break;
    				case 2:
    					Cala(Sub);
    				case 3:
    						Cala(Mul);
    						break;
    				case 4:
    					Cala(Div);
    						break;
    				case 5:
    						printf("退出计算器\n");
    						break;
    				default:
    						printf("输入数字无效，请重新输入\n");
    						break;
    			}
    	} while (input);
    	return 0;
    }

## 九、指针和数组笔试题 ##

### 9.1 一维数组 ###

> int  a \[\]  =  \{  1 , 2 , 3 , 4 \}; 
> 
> printf ( "%d\\n" , sizeof ( a ));//整个数组的大小，16个字节
> 
> printf ( "%d\\n" , sizeof ( a \+ 0 ));//数组名a是首元素地址，a+0还是首元素的地址，地址大小为4/8个字节
> 
> printf ( "%d\\n" , sizeof ( \* a ));//数组名a是首元素地址，\*a就是首元素，大小就是4个字节
> 
> printf ( "%d\\n" , sizeof ( a \+ 1 ));//数组名a是首元素地址，数组名a+1是第二个元素地址，是地址大小就是4/8个字节
> 
> printf ( "%d\\n" , sizeof ( a \[ 1 \]));//元素大小，4个字节
> 
> printf ( "%d\\n" , sizeof ( & a ));//&a是数组的地址，是地址就是4/8个字节
> 
> printf ( "%d\\n" , sizeof ( \*& a ));// sizeof ( \*& a )== sizeof ( a )，16个字节
> 
> printf ( "%d\\n" , sizeof ( & a \+ 1 ));//&a是数组的地址，&a+1就是跳过此数组的地址，是地址就是4/8个字节
> 
> printf ( "%d\\n" , sizeof ( & a \[ 0 \]));//&a\[0\]首元素地址，4/8个字节
> 
> printf ( "%d\\n" , sizeof ( & a \[ 0 \] \+ 1 ));第二个元素的地址，4/8个字节

### 9.2 字符数组 ###

> char  arr \[\]  =  \{  'a' , 'b' , 'c' , 'd' , 'e' , 'f' \}; 
> 
> printf ( "%d\\n" ,  sizeof ( arr ));// 整个数组大小，6个字节
> 
> printf ( "%d\\n" ,  sizeof ( arr \+ 0 ));//数组名arr是首元素地址，a+0还是首元素的地址，地址大小为4/8个字节
> 
> printf ( "%d\\n" ,  sizeof ( \* arr ));//数组名arr是首元素地址，\*arr就是首元素，大小就是1个字节
> 
> printf ( "%d\\n" ,  sizeof ( arr \[ 1 \]));//元素大小，1个字节
> 
> printf ( "%d\\n" ,  sizeof ( & arr ));//&arr是数组的地址，是地址就是4/8个字节
> 
> printf ( "%d\\n" ,  sizeof ( & arr \+ 1 ));//&arr是数组的地址，&arr+1就是跳过此数组的地址，是地址就是4/8个字节
> 
> printf ( "%d\\n" ,  sizeof ( & arr \[ 0 \] \+ 1 ));//&a\[0\]首元素地址，&a\[0\]+1是第二个元素的地址，4/8个字节
> 
> printf ( "%d\\n" ,  strlen ( arr ));//因为字符数组arr中没有\\0，所以在求字符串长度的时候，会一直往后找，产生的结构就是随机值
> 
> printf ( "%d\\n" ,  strlen ( arr \+ 0 ));//arr + 0是首元素的地址，和第一个一样，也是随机值
> 
> printf ( "%d\\n" ,  strlen ( \* arr )); //error，strlen函数参数的部分需要传一个地址，当我们传递是'a'时，'a'的ASCII码值是97，那就是将97作为地址传参，strlen就会从97这个地址开始统计字符串长度，这就非法访问内存了
> 
> printf ( "%d\\n" ,  strlen ( arr \[ 1 \]));//如上同样问题
> 
> printf ( "%d\\n" ,  strlen ( & arr ));//&arr是数组的地址,数组的地址和数组首元素的地址，值是一样的，那么传递给strlen函数后，依然是从数组的第一个元素的位置开始往后统计
> 
> printf ( "%d\\n" ,  strlen ( & arr \+ 1 ));//随机值
> 
> printf ( "%d\\n" ,  strlen ( & arr \[ 0 \] \+ 1 ));&arr\[0\] + 1是第二个元素的地址。结果也是随机值

> char  arr \[\]  =  "abcdef" ;//\[a b c d e f \\0\]
> 
> printf ( "%d\\n" ,  sizeof ( arr ));//数组大小，7
> 
> printf ( "%d\\n" ,  sizeof ( arr \+ 0 ));//首元素地址大小，4/8
> 
> printf ( "%d\\n" ,  sizeof ( \* arr ));//首元素大小，1
> 
> printf ( "%d\\n" ,  sizeof ( arr \[ 1 \]));//第二个元素大小。1
> 
> printf ( "%d\\n" ,  sizeof ( & arr ));//地址，4/8
> 
> printf ( "%d\\n" ,  sizeof ( & arr \+ 1 ));//地址
> 
> printf ( "%d\\n" ,  sizeof ( & arr \[ 0 \] \+ 1 ));//地址
> 
> printf ( "%d\\n" ,  strlen ( arr ));//6
> 
> printf ( "%d\\n" ,  strlen ( arr \+ 0 ));//6
> 
> printf ( "%d\\n" ,  strlen ( \* arr ));//error
> 
> printf ( "%d\\n" ,  strlen ( arr \[ 1 \]));//error
> 
> printf ( "%d\\n" ,  strlen ( & arr ));//首地址，6
> 
> printf ( "%d\\n" ,  strlen ( & arr \+ 1 ));//跳过整个数组的地址，随机值
> 
> printf ( "%d\\n" ,  strlen ( & arr\[0\]+1);//从第二个元素的地址开始查找，5

> char \* p  =  "abcdef" ;//p指针变量，存放地址
> 
> printf ( "%d\\n" ,  sizeof ( p ));// 大小是4/8
> 
> printf ( "%d\\n" ,  sizeof ( p \+ 1 ));//p+1是b的地址
> 
> printf ( "%d\\n" ,  sizeof ( \* p ));//\*p是首元素 1
> 
> printf ( "%d\\n" ,  sizeof ( p \[ 0 \]));//首元素 
> 
> printf ( "%d\\n" ,  sizeof ( & p )); //地址
> 
> printf ( "%d\\n" ,  sizeof ( & p \+ 1 ));//跳过p所在地址，还是地址
> 
> printf ( "%d\\n" , sizeof ( &p\[0\] \+ 1 ));//b的地址
> 
> printf ( "%d\\n" ,  strlen ( p ));//6
> 
> printf ( "%d\\n" ,  strlen ( p \+ 1 ));//p+1-->b,5
> 
> printf ( "%d\\n" ,  strlen ( \* p ));//error
> 
> printf ( "%d\\n" ,  strlen ( p \[ 0 \]));//error
> 
> printf ( "%d\\n" ,  strlen ( & p ));//随机值
> 
> printf ( "%d\\n" ,  strlen ( & p \+ 1 ));//随机值
> 
> printf ( "%d\\n" ,  strlen ( & p \[ 0 \] \+ 1 ));//p+1-->b,5

### 9.3 二维数组 ###

> int  a \[ 3 \]\[ 4 \]  =  \{  0 \}; 
> 
> printf ( "%d\\n" , sizeof ( a ));//整个数组大小 48个字节
> 
> printf ( "%d\\n" , sizeof ( a \[ 0 \]\[ 0 \]));//第1行第1列元素 ，4个字节
> 
> printf ( "%d\\n" , sizeof ( a \[ 0 \]));//第1行的大小 ，16个字节
> 
> printf ( "%d\\n" , sizeof ( a \[ 0 \] \+ 1 ));//a\[0\]可以是第1行的数组名，在这里a\[0\]是是数组首元素地址，也就是a\[0\]\[0\]的地址，其加1为第1行第1列元素地址，大小为4/8个字节
> 
> printf ( "%d\\n" , sizeof ( \* ( a \[ 0 \] \+ 1 )));//第2行大小，4个字节
> 
> printf ( "%d\\n" , sizeof ( a \+ 1 ));//a是数组首元素地址就是第一行地址，a+1就是第二行地址，4/8个字节
> 
> printf ( "%d\\n" , sizeof ( \* ( a \+ 1 )));//第二行数组大小，16个字节
> 
> printf ( "%d\\n" , sizeof ( & a \[ 0 \] \+ 1 ));//第二行地址大小，4/8个字节
> 
> printf ( "%d\\n" , sizeof ( \* ( & a \[ 0 \] \+ 1 )));//第二行数组大小，16字节
> 
> printf ( "%d\\n" , sizeof ( \* a ));//a是第一行地址，大小16字节
> 
> printf ( "%d\\n" , sizeof ( a \[ 3 \]));//a\[3\]-->int \[4\] 16字节

总结：

1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。

2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。

3. 除此之外所有的数组名都表示首元素的地址。

[880f7f1dbd7d492092a22635ee2a4ced.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/990db95a3bf84c129e41bb71c9d8aa37.png