指针进阶详解!!!，干货满满（上）

1. 字符指针

2. 数组指针

3. 指针数组

4. 数组传参和指针传参

5. 函数指针

6. 函数指针数组

7. 指向函数指针数组的指针

8. 回调函数

9. 指针和数组面试题的解析

指针的主题，我们在初级阶段的《指针》章节已经接触过了，

我们知道了指针的概念：

1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。

2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。

3. 指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。

4. 指针的运算。

字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* ;

int main()

{    

char ch = 'w';  

char *pc = &ch;    

*pc = 'w';    

return 0;

}

这里char ch='w'就是把w赋值给ch这个字符型变量，所以在取地址的时候，我们用char* 来接收才是最好的。

不要与下面的代码混淆了

int main()

{  

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

return 0;

}

这个第一行代码，这个字符串在赋值给pstr时其实存的是起始地址(也就是h这个字符的地址)，而我们%s打印输出的是字符串，也就是说，printf这串代码在执行的时候会去寻找从pstr这个指向的地址的空间的字符数据并打印。

上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。 那就有可这样的面试题：

#include <stdio.h>
int main()
{
   char str1[] = "hello bit.";
   char str2[] = "hello bit.";
   const char* str3 = "hello bit.";
   const char* str4 = "hello bit.";
   if (str1 == str2)
       printf("str1 and str2 are same\n");
   else
       printf("str1 and str2 are not same\n");

   if (str3 == str4)
       printf("str3 and str4 are same\n");
   else
       printf("str3 and str4 are not same\n");

   return 0;
}

思考一下？

为什么会这样呢？

这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域. 当 几个指针，指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化 不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不相同。

我们再来看一看小伙伴容易错的部分：

#include <stdio.h>
int main()
{
    char ch = 'w';
    char* chx = &ch;
    char* c = "hello boy";
    *chx = 'c';
    *c = 'w';
    return 0;
}

那我们想一想怎么可以改呢？

我们可以用一个数组去接受这个字符串，然后利用这个数组去改存的字符串的值

指针数组

int* arr1[10]; //整形指针的数组

char *arr2[4]; //一级字符指针的数组

char **arr3[5];//二级字符指针的数组

那什么是指针数组呢，就是有个数组，里面的元素存放的都是相同类型地址。

图例

类型可以是整形地址，字符地址等等，也可以是结构体地址

例子1：

#include <stdio.h>
int main()
{
    char* ch[4] = { "hello","world","baby","sas" };
    for (int i = 0;i < 4;i++)
    {
        printf("%s ", ch[i]);
    }
    return 0;
}

那么就有人问了？初始化arr的{“hello”, “world”, “baby, “sas”};的是什么鬼？

这四个不是什么鬼，他们也存在在内存中，只是跟arr这个变量不在同一段空间，它们被分配在只读数据区，数组arr[4]的四个指针元素，分别存放着这四个字符串的首地址，想象一下，从栈区有四只无形的手指向数据区的空间。arr+1会跳过四个字节，。也就是一个指针的大小

例子2：

#include <stdio.h>
int main()
{
    int arr1[] = { 0,1 };//整形数组
    int arr2[] = { 2,1 };//整形数组
    int arr3[] = { 3,1 };//整形数组
    int* arr[3] = { arr1,arr2,arr3 };
    int j = 0;
    for (int i = 0;i < 3;i++)
    {
        printf("%d ", arr[i][j]);
    }
    return 0;
}

arr[0]这个指向的arr这个数组的第一个元素（arr1整个数组）的地址，而arr[0][0]，这个指向的是arr

这个数组的第一个元素（arr1数组）的首元素地址的值所以打印 0 2 3

&数组名VS数组名

arr 和 &arr 分别是啥？

我们知道arr是数组名，

数组名表示数组首元素的地址。

那&arr数组名到底是啥？

我们看一段代码：

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    printf("%p\n", arr);
    printf("%p\n", &arr);
    return 0;
}

打印的都是首元素地址；

再看一段代码：

#include <stdio.h>
int main()
{
 int arr[10] = { 0 };
 printf("arr = %p\n", arr);
 printf("&arr= %p\n", &arr);
 printf("arr+1 = %p\n", arr+1);
 printf("&arr+1= %p\n", &arr+1);
 return 0;
}

&arr+1是跳过整个数组，&arr指向的是数组首元素地址，但是本质是取出整个数组，arr+1，是跳过一个int类型的数据。

数组指针的使用

  什么是数组指针

  数组指针指向的是整个数组。

既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。

#include <stdio.h>
int main()
{
   int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
   int(*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
   //但是我们一般很少这样写代码
   return 0;
}

一般这样用

#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
    int i = 0;
    int j = 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;
    int j = 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;
}

char (*pa)[4];

如果指针数组和数组指针这俩个变量名称一样就会是这样：char *pa[4]和char (*pa)[4]，原来指针数组和数组指针的形成的根本原因就是运算符的优先级问题，所以定义变量是一定要注意这个问题，否则定义变量会有根本性差别！

pa是一个指针指向一个char [4]的数组，每个数组元素是一个char类型的变量，所以我们不妨可以写成：char[4] (*pa);这样就可以直观的看出pa的指向的类型，不过在编辑器中不要这么写，因为编译器根本不认识，这样写只是帮助我们理解。

既然pa是一个指针，存放一个数组的地址，那么在我们定义一个数组时，数组名称就是这个数组的首地址，那么这二者有什么区别和联系呢？

上面验证过，

那我们再来看个例子

数组参数、指针参数

在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？

例题:

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

第一行代码中，为什么没有定义数组大小也可以？

在用数组名作函数参数的时候，不是进行值的传送，即不是把实参数组的每一个元素的值都赋予形参数组的各个元素。因为实际上形参数组并不存在， 编译器不会形参数组分配内存。所以在形参接收时不用定义下标，只用知道是上面数据类型即可

那么数组在传参时是用上面传的呢？

用的是数组名，数组名就是首元素地址，所以形参实际接收到的是一个地址

二维数组传参

void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr)//ok？
{}
void test(int* arr[5])//ok？
{}
void test(int(*arr)[5])//ok？
{}
void test(int** arr)//ok？
{}
int main()
{
  int arr[3][5] = { 0 };
  test(arr);
}

先看一下，再修改

一级指针传参

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