C语言指针详解进阶1

字符指针

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

一般使用:

int main() {
    char ch = 'w';
    char *pc = &ch;
    *pc = 'w';
    char* p = "abcdef";//[abcdef\0] 
                       //char arr[] = "abcdef"
    return 0;
}

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

代码 const char* pstr = "hello world.";

特别容易让人以为是把字符串"hello world." 放到字符指针 pstr 里了，但是本质是把字符串首字符'h'的地址放到了pstr中。

上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。

那就有可这样的面试题:

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

指针数组

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

指针数组是指一个数组的元素值为指针的数组。

它有三个主要特点：首先，它是一个数组，具有数组的属性和使用方法；

其次，数组的每个元素都是指针。指针数组是一组有序的指针的集合，其中每个元素都是具有相同存储类型和指向相同数据类型的指针变量。

例如，我们可以定义一个int类型的指针数组int *p，其中p到p都是int类型的指针变量。类似地，我们也可以定义指向其他数据类型的指针数组，比如float类型的指针数组float *p1。

第三，也可以使用指针数组模拟一个二维数组，可以通过申请一个数组的数组来实现。

数组指针

数组指针的定义

数组指针是指针? 还是数组?

答案是:指针。

我们已经熟悉:

整形指针: 能够指向整形数据的指针。

浮点型指针: 能够指向浮点型数据的指针。

那数组指针应该是:能够指向数组的指针。

区分数组指针和指针数组

“数组指针”和“指针数组”，只要在名词中间加上“的”字，就知道中心了——

数组的指针：是一个指针，什么样的指针呢？指向数组的指针。

指针的数组：是一个数组，什么样的数组呢？装着指针的数组。

然后，需要明确一个优先级顺序：()>[]>*，所以：

(*p)[n]：根据优先级，先看括号内，则p是一个指针，这个指针指向一个一维数组，数组长度为n，这是“数组的指针”，即数组指针；

*p[n]：根据优先级，先看[]，则p是一个数组，再结合*，这个数组的元素是指针类型，共n个元素，这是“指针的数组”，即指针数组。

根据上面两个分析，可以看出，p是什么，则词组的中心词就是什么，即数组“指针”和指针“数组”。

&数组名VS数组名

对于下面的数组:

int arr[10];

arr 和 &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和arr，虽然值是一样的，但是意义应该不一样的。

实际上: &arr 表示的是数组的地址，而不是数组首元素的地址。

本例中&arr 的类型是:int (*)[10] ，是一种数组指针类型

数组的地址+1，跳过整个数组的大小，所以 相对于 &arr 的差值是40.

举例

数组指针 (*p)[n]

//一维数组
  int a[5] = { 1, 2, 3, 4, 5 };
  //步长为5的数组指针，即数组里有5个元素
  int (*p)[5];
  //把数组a的地址赋给p，则p为数组a的地址，则*p表示数组a本身
  p = &a;

printf("%p\n", a); //输出数组名，一般用数组的首元素地址来标识一个数组，则输出数组首元素地址
printf("%p\n", p); //根据上面，p为数组a的地址，输出数组a的地址
printf("%p\n", *p); //*p表示数组a本身，一般用数组的首元素地址来标识一个数组
printf("%p\n", &a[0]); //a[0]的地址
printf("%p\n", &a[1]); //a[1]的地址
printf("%p\n", p[0]); //数组首元素的地址

指针数组 *p[n]

int a = 1;
  int b = 2;
  int *p[2];
  p[0] = &a;
  p[1] = &b;
 
  printf("%p\n", p[0]); //a的地址
  printf("%p\n", &a); //a的地址
  printf("%p\n", p[1]); //b的地址
  printf("%p\n", &b); //b的地址
  printf("%d\n", *p[0]); //p[0]表示a的地址，则*p[0]表示a的值
  printf("%d\n", *p[1]); //p[1]表示b的地址，则*p[1]表示b的值

数组指针的使用

那数组指针是怎么使用的呢?

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

看代码:

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

数组参数、指针参数

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

数组传参，形参是可以写成数组形式的！

数组传参得本质是，传递了数组首元素的地址

数组传参，形式也可以是指针！

一维数组传参

在C语言中，一维数组可以通过两种方式进行传参。第一种方式是使用指针，函数的形参可以是一个指针变量。例如，在函数定义中，可以使用int arr[]或者int *arr来定义形参。这种方式传递的是数组的首地址，函数内部可以通过指针来访问数组中的元素。`这样的形式来定义参数。这种方式与指针方式类似，传递的也是数组的首地址，但是在函数内部，可以通过数组名来访问数组中的元素。

因此，无论是使用指针方式还是数组方式，都可以实现对一维数组的传参。选择使用哪种方式，可以根据具体的需求和代码的可读性来决定。

二维数组传参

二维数组可以通过三种传参方式进行传递。

首先是使用int arr的方式，其中行数和列数需要在函数形参中显式声明。

第二种传参方式是使用int arr[][列数]的方式，省略了行数的声明。需要注意的是，列数不能省略。例如，可以定义函数void Print(int arr[][4], int m, int n)来接收二维数组。

第三种传参方式是使用数组指针的方式，通过int(*p)[列数来接收二维数组。其中p是一个指向一维数组的指针。可以使用int(*p)[4 = arr来将二维数组传递给p。然后，在函数定义中，可以使用void Print(int(*p)[4], int m, int n)来操作二维数组。

总结来说，这三种传参方式都可以用来传递二维数组，但需要根据实际情况选择合适的方式。

一级指针传参

一级指针传参是指将指针的地址传递给函数，以便在函数内部对指针所指向的内容进行修改。通过传递一级指针的地址，函数可以通过指针解引用来修改指针所指向的值。

在C语言中，可以通过传址调用的方式将一级指针作为函数的形参进行传递。这意味着函数的形参是一个指向指针的指例如，在函数声明中可以使用类似void function(int** p)的语法来定义函数的形参为一级指针。在调用函数时，可以将一级指针的地址传递给这个函数。

另外，也可以使用二级指针来进行一级指针的传参。通过将一级指针的地址赋值给一个二级指针，然后将这个二级指针作为函数的形参进行传递。例如，可以使用int** ppa = &pa;将一级指针pa的地址赋值给二级指针ppa，然后将ppa作为函数的形参进行传递。

总结起来，一级指针传参可以通过传址调用或者使用二级指针来实现。传址调用是将一级指针的地址传递给函数作为参数，而使用二级指针是将一级指针的地址赋值给一个二级指针，然后将这个二级指针作为参数传递给函数。这样可以在函数内部对指针所指向的内容进行修改。

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

二级指针传参

二级指针传参是在C/C++中常见的一种传递多维数组值的方式。当二级指针作为函数形参时，能作为函数实参的是二级指针、指针数组和一级指针的地址。当数组指针作为函数形参时，能作为函数实参的是二维数组和数组指针。当二维数组作为函数形参时，能作为函数实参的是能作为函数实参的是指针数组、二级指针和一级指针的地址。

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

函数指针

函数指针是指向函数的指针变量。它可以用于调用函数和作为函数的参数。在C语言中，每个函数都有一个入口地址，这个地址就是函数指针所指向的地址。通过函数指针变量，我们可以像引用其他类型变量一样引用函数。

举个例子，我们可以使用结构体来定义一个包含函数指针的结构体变量。比如在引用中的例子中，定义了一个名为struct func的结构体，其中包含了两个函数指针add和sub。然后我们可以将具体的函数赋值给这两个指针变量，如test_add和test_sub。通过结构体变量func2可以调用这两个函数指针，实现了对函数的调用。

另外一个例子是在引用中的代码中，我们定义了一个函数指针变量fun，并将其指向add函数。然后我们可以通过fun调用add函数，获得add函数的返回值。接着我们将fun指向sub函数，通过fun调用sub函数，获得sub函数的返回值。

所以，函数指针可以让我们以一种动态的方式调用不同的函数，具有较高的灵活性和可扩展性。

首先看一段代码:

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

输出的结果:

输出的是两个地址，这两个地址是 test 函数的地址。

那我们的函数的地址要想保存起来，怎么保存?

下面我们看代码

void test() {
    printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址? 
void (*pfun1)();
void *pfun2();

首先，能给存储地址，就要求pfun1或者pfun2是指针，那哪个是指针?

答案是:pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。

阅读两段有趣的代码:

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

(*(void (*)())0)();

代码一：

void* 是一种返回任意类型指针的强大工具，但一般情况下最好不要使用。

现在来解释一下问题中的代码 (*(void(*)())0)();。这是一个函数指针调用的表达式。

它首先将一个空指针强制类型转换为指向函数的指针，

然后对该指针进行解引用并调用该函数。

这里的函数指针类型为 void (*)()，表示接受任意参数并返回空类型的函数指针。

此代码的意义是调用0地址处的函数

该函数无参，返回类型是void

代码拆分（原文链接：https://blog.csdn.net/Mr_Guan/article/details/131391907 ）

1.void ( * ) ( ) ：是函数指针类型

2.( void ( * ) ( ) ) 0 ：对0进行强制类型转换，被解释为一个函数地址

3.*( void ( * ) ( ) ) 0 ：对0地址进行解引用操作

4.( * ( void ( * ) ( ) ) 0 ) ( ) ：调用0地址处的函数

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

代码二：

void (*signal(int, void(*)(int)))(int)是一个函数，它接受两个参数：一个是int类型的，一个是void (*)(int)类型的函数指针。这个函数返回一个指向void类型返回值的函数指针，该函数接受一个int类型的参数。

详细分析原文链接： https://blog.csdn.net/Mr_Guan/article/details/131393053

signal先和（）结合，说明signal是一个函数名

signal函数有两个参数，第一个参数的类型是int，第二个参数的类型是函数指针（该函数指针指向一个参数是int，返回值是void的函数）

signal函数的返回类型也是一个函数指针（该函数指针指向一个参数是int，返回值是void的函数）

综上所述，signal是一个函数的声明

 

其实将void (* signal ( int, void ( * ) ( int ) ) ) ( int )此段代码写成下面这种形式其实更容易理解：

void (*) (int) (* signal (int, void (*) (int)))

这样来看，signal函数的参数以及返回值就更加清晰了，但语法格式不允许这样书写。

我们也可以将上述signal函数的返回值以typedef的形式重命名

typedef void(*pfun_t)(int);

需要注意的是在这种形式下我们依旧需要按照刚才提到的传统语法格式来书写，对void(*)(int)的函数指针类型重命名为pfun_t。在此基础上signal函数的声明可以写为

pfun_t signal(int, pfun_t)；