如何学习指针（3）

开始学习前，先说明一下，下述所写代码均是伪代码哦。

1.字符指针变量

char*指针变量一般是两种初始化

//第一种
char ch = 'w';
char *p = &ch;

//------------

//第二种
char *p="abcdefg";

第二种值得强调的是p中存储的是字符串的首元素的地址。

char *pa="abcdef";

char *pb="abcdef";

char arr1[]="abcdef";

char arr2[]="abcdef";

//pa==pb;        arr1!=arr2;

上述代码中pa和pb指向的是⼀个同⼀个常量字符串。C/C++会把常量字符串存储到单独的⼀个内存区域， 当几个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以pa和pb相同，而arr1和arr2不同。

2.数组指针变量

数组指针，顾名思义，就是存放数组地址的指针变量。

数组指针变量的初始化

int arr[5]={0};

int (*p)[5]=&arr;//p所指向的地址即为&arr。&arr和p的类型是完全⼀致的。

我们应该知道，[ ]的优先级是大于'*',此处用（）将'*'与'p'括起来，使得'*'与'p'先进行运算，是为了确保*p是指针变量，从而确保整个语句是数组指针。前面我们说过，指针数组的形式是int *arr[5]，这里没有（），则arr先于[ ]进行了运算，使得arr[ ]是数组变量。

3.二维数组传参的本质

前面我们用指针数组模拟实现了二维数组，这里学习了数组指针后就可以了解二维数组传参的本质了。一维数组传参的本质是传递首元素的地址，二维数组传参的本质是传递第一行的地址（非首元素地址），即二维数组数组名表示的是第一行的地址。

void test(int (*p)[5])//二维数组的列数是多少，[]内的数就是多少
{
    printf("%p\n",p);
    printf("%p\n",p+1);
    printf("%p\n",p+2);
}

int main()
{    
    int arr[3][5]={ { 0, 1, 2, 3, 4 },
                { 1, 2, 3, 4, 5 },
                { 2, 3, 4, 5, 6 }}
    
    printf("%p\n",&arr[0]);//arr[0]是第一行的数组名，表示第一行的首元素地址    printf("%p\n",&arr[1]);    //&arr[0]是&加上数组名，取出的是第一行的地址
    printf("%p\n",&arr[2]);//arr[1]与arr[2]同理可得。
    test(arr);
    return 0;
}

//可以发现，p==&arr[0];    p+1==&arr[1];    p+2==&arr[2];

知道二维数组传参的本质后，就可以用数组指针模拟实现二维数组了。p ==&arr[0];

则*p=arr[0]，得到了第一行的首元素的地址。同理，*（p+1）=arr[1]，得到了第而行的首元素的地址，*（p+2）=arr[0]，得到了第三行的首元素的地址。前面我们讲过，arr[i][j]=*(arr[i]+j)，arr[i]=*(p+i);。那么* *p==*arr[0]==*( *（p+0）+0)==*（p[0]+0)==p[0][0]==arr[0][0]，是对第一行的首元素的地址进行解引用操作得到第一行的首元素，则*（*（p+0）+1）==p[0][1]=arr[0][1]，得到第一行第二个元素，*（*（p+1）+3）==p[1][3]=arr[1][3]，得到第二行第四个元素，其它不再赘述。

#include <stdio.h>
void test(int (*p)[5], int r, int c)//用数组指针模拟实现二维数组
{ int i = 0;

int j = 0; 7 for(i=0; i<r; i++)
{
for(j=0; j<c; 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}};
test(arr, 3, 5);
return 0;
}

4.函数指针变量

函数指针变量，顾名思义，是一个存放函数地址的指针变量。

函数指针变量初始化

int test()
{

}

int main()
{
    int (*pa)()=test;
    int (*pb)()=&test;
    return 0;
}

在数组中数组名和&加数组名是不同的，而在函数这里是相同的，没有区别。int是test函数的返回类型，（）的作用是确保*p是指针，从而整个语句是指针变量。

5.两段有趣的代码

第一个有趣的代码：(*(void (*)())0)();


首先，可以看出void (*)()是一个函数指针变量类型

void (*)()0是将0强制类型转换为函数指针变量类型

（*void (*)()0）是将地址为0的函数解引用，（*void (*)()0）可以理解为函数名。（*void (*)()0）()则
得到一个函数。

解析：

int *p=NULL;
char *ch=(char *)p;
char *是一个字符指针变量类型，
(char *)p是将p强制类型转换为字符指针变量类型。

*((char *)p)中，(char *)p是一个地址，*((char *)p)就是一个解引用操作，解引用得到了地址(char *)p中的内容。


同理，（*void (*)()0）是将地址为0的函数解引用，得到的是一个函数名。

加上括号，（*void (*)()0）()就得到一个函数。

第二个有趣的代码： void (*signal(int , void(*)(int)))(int);

拆成两个部分

1.void (*)(int)

2.signal(int,void(*)(int))

void (*)(int)是一个函数指针变量类型，signal(int,void(*)(int))是一个函数。

结合起来就是函数signal(int,void(*)(int))的返回值是一个void (*)(int)的函数指针变量类型。

6.函数指针数组

函数指针数组，顾名思义，是存放函数指针，也就是存放函数地址的数组。基本形式为

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 (*arr[4])()={add,sub,mul,div};

    return 0;
}

//在main函数里使用arr[0]表示对add函数的调用，其它同上

博主本人也是菜鸟，这些是我学习后总结出来的知识点，希望可以帮到大家，大家互相学习，共同进步。欢迎大家指出错误。