C语言指针进阶(一)

一.字符指针

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

#include 
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
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个字节
}

可以看到整个数组的地址和首元素的地址虽然一样但是+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 
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 
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 
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 
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;