C语言指针进阶

最新推荐文章于 2024-11-14 22:16:00 发布

山楂树の

最新推荐文章于 2024-11-14 22:16:00 发布

阅读量235

点赞数 6

分类专栏： C语言文章标签： c语言开发语言

本文链接：https://blog.csdn.net/dabaooooq/article/details/134288218

版权

C语言专栏收录该内容

15 篇文章 3 订阅

订阅专栏

解释： (*(void (*)())0)();

解释： void (*signal(int, void (*)(int)))(int);

函数指针数组指针

数组指针

数组指针——>指向数组的指针

    int ary[10] = {0};
    int p = ary;
    int *p1[10];         // p1是指针数组
    int(*p2)[10] = &ary; // p2是数组指针，（&ary取的是整个数组的地址）p2可以指向一个数组，该数组有10个元素，每个元素是int类型,数组指针的类型是int (*)[10]

指针数组访问数组元素

    int arr1[] = {1, 2, 3, 4, 5};
    int arr2[] = {2, 3, 4, 5, 6};
    int arr3[] = {3, 4, 5, 6, 7};
    int *parr[3] = {arr1, arr2, arr3}; // 指针数组
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            /* *(p+i) ——> p[i] */
            // printf("%d ", *(parr[i] + j));
            printf("%d ", parr[i][j]);
        }
        printf("\n");
    }

再次讨论数组名

数组名通常表示的都是数组首元素的地址
但是有2个例外：
1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小
2. &数组名，这里的数组名表示的依然是整个数组，所以&数组名取出的是整个数组的地址

例

    int arr[10] = {0};
    printf("%p\n", arr);     // 0000003199fff960
    printf("%p\n", arr + 1); // 0000003199fff964 加4个字节

    printf("%p\n", &arr[0]);     // 0000003199fff960
    printf("%p\n", &arr[0] + 1); // 0000003199fff964 加4个字节

    printf("%p\n", &arr);     // 0000003199fff960
    printf("%p\n", &arr + 1); // 0000003199fff988 加40个字节

数组指针访问一维数组（但是这样会很别扭）

    int ARR[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int(*P)[10] = &ARR;
    int SZ = sizeof(ARR) / sizeof(ARR[0]);
    for (int i = 0; i < SZ; i++)
    {
        /* 1 2 3 4 5 6 7 8 9 10 */
        printf("%d", *(*P + i)); // P指向数组的人，*P其实就相当于数组名，数组名又是数组首元素的地址。所以*p本质上就是数组首元素的地址
    }
    printf("\n");

思考一下：与其 int(*P)[10] = &ARR 这么麻烦，为什么不直接使用 int *p = arr 呢？这是因为数组指针的更适合和二维数组相结合，如下

访问二维数组元素

非数组指针访问

    int ARRAY[3][5] = {
        1, 2, 3, 4, 5,
        2, 3, 4, 5, 6,
        3, 4, 5, 6, 7};

    void printf1(int arr[3][5], int r, int c)
    {
        for (int i = 0; i < r; i++)
        {
            for (int j = 0; j < c; j++)
            {
                printf("%d", arr[i][j]);
            }
            printf("\n");
        }
    }
    printf1(ARRAY, 3, 5);

数组指针访问

    int ARRAY[3][5] = {
        1, 2, 3, 4, 5,
        2, 3, 4, 5, 6,
        3, 4, 5, 6, 7};

    void printf2(int (*p)[5], int r, int c) // p指向第一个数组的地址
    {
        for (int i = 0; i < r; i++)
        {
            for (int j = 0; j < c; j++)
            {
                /*
                p+i 是每个一维数组的地址，*(p + i)解引用得到每个数组arr，arr又是每个数组的首元素    地址，进一步找到每个数组的每个元素的地址arr+j ——>  *(p + i) + j
             */
            // printf("%d", *(*(p + i) + j)); // p每次加1，跳过 20个字节，即以每个数组为单位，每次加1跳过 5 个int
                printf("%d", p[i][j]); // 同上面一致
            }
            printf("\n");
        }
    }

数组传参Demo

一维数组传参

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

二维数组传参

        void test(int arr[3][5]) ok
        {}
        void test(int arr[][]) err 形参的二维数组，行可以省略，列不能省略
        {}
        void test(int arr[][5]) ok
        {}
        总结：二维数组传参，函数形参的设计只能省略第一个，因为对一个二维数组，可以不知道有多少行，但是必须知道多少列

        void test(int *arr) err 传过来的是arr第一个数组的地址，不是一个整形的地址
        {}
        void test(int *arr[5]) err 这里表示指针数组，arr是五个指针的数组
        {}
        void test(int (*arr)[5]) ok
        {}
        void test(int **arr) ok
        {}

        int arr[3][5] = {0};
        test(arr);

指针数组指针

指向用于存放指针的数组的

    char *Arr[5] = {0};    // 指针数组
    char *(*Pc)[5] = &Arr; // Pc可以指向一个数组，该数组有5个元素，每个元素是char*类型，数组指针的类型是char* (*)[5]

字符指针

字符指针——>指向字符的指针

    char *p = "abcdef"; // 把字符串首字符a的地址，赋值给了p
    printf("%c\n", *p); // a

    char *p1 = "abcdef";
    char *p2 = "abcdef";
    char arr1[] = "abcdef";
    char arr2[] = "abcdef";
    if (p1 == p2)
    {
        printf("p1 == p2\n"); // p1 == p2
    }
    else
    {
        printf("p1 != p2\n");
    }
    if (arr1 == arr2)
    {
        printf("arr1 == arr2\n");
    }
    else
    {
        printf("arr1 != arr2\n"); // arr1 != arr2
    }

函数指针

函数指针是指向函数的指针变量。函数指针可以让你像普通变量一样操作函数，也可以将函数作为参数传递给其他函数

函数也有地址

int Add(int x, int y)
{
    return x + y;
}
printf("%p\n", &Add);       // 00007ff7f9ff1591
printf("%p\n", Add);        // 00007ff7f9ff1591

函数指针调用时可以不用写*解引用

    int (*pf)(int, int) = &Add; //  pf是一个函数指针，参数类型是(int, int) 返回类型为int的函数
    int res = (*pf)(2, 3);      // 调用函数指针所指向的函数
    /*
		函数指针调用时可以不用写*解引用
        int (*pf)(int, int) = Add 等同于 int *p = &num; p == &num
        int res = Add(2, 3);
        int res = pf(2, 3);
     */
    int resp = pf(2, 3); // 可以不用写*
    printf("%d\n", res); // 5

函数作为回调传参

void calc(int (*pf)(int, int))
{
    int a = 3;
    int b = 5;
    int res = (*pf)(a, b);
    // int res = pf(a, b);
    printf("%d\n", res); // 8
}
/*
调用calc函数
 */
calc(Add);

解释： ((void ()())0)();

   void (*)() 表示一个函数指针，指向一个无返回值的函数，并且该函数没有参数。
   (void (*)())0 将整数 0 强制转换为一个函数指针
   将这个函数指针解引用，这意味着它试图调用指向地址 0 的函数。

解释： void (signal(int, void ()(int)))(int);

    typedef unsigned int uint;
    typedef void (*pf_t)(int);
    void (*signal(int, void (*)(int)))(int);
    pf_t signal(int, pf_t); // 和上式相同

typedef unsigned int uint; 这句代码定义了一个新的数据类型 uint，它是无符号整型的别名，方便在程序中使用无符号整型时进行声明。
typedef void (*pf_t)(int); 这句代码定义了一个新的数据类型 pf_t，它是一个指向参数为整型、无返回值的函数指针类型。这样的定义可以方便地声明类似这种类型的函数指针变量。
void (*signal(int, void (*)(int)))(int); 这行代码声明了一个名为 signal 的函数，它接受两个参数：一个整型和一个指向参数为整型、无返回值的函数指针。它的返回类型是一个指向参数为整型、无返回值的函数指针。这种类型的函数通常用于信号处理。
pf_t signal(int, pf_t); 这行代码是函数 signal 的声明，它使用了之前定义的 pf_t 类型。它表明函数 signal 接受两个参数，一个整型和一个指向参数为整型、无返回值的函数指针，然后返回一个指向参数为整型、无返回值的函数指针。

函数指针数组指针

指向函数指针数组的指针

&先看函数指针数组：函数指针也是指针，把函数和指针放在数组中，其实就是函数指针数组

    int (*pf)(int, int) = Add;                      // pf是函数指针
    int (*arr[4])(int, int) = {Add, Sub, Mul, Div}; // arr就是函数指针的数组
    for (int i = 0; i < 4; i++)
    {
        // int res = arr[i](2, 1); // 可以直接用arr[i]是因为，比如int (*pf)(int, int) = Add; 指针函数pf的类型是int (*)(int, int) 那么Add == pf
        int res = (*arr[i])(2, 1); // 也可以解引用，因为arr[i]指向的是函数地址 Add等函数地址
        printf("%d\n", res);       // 3, 1, 2, 2
    }

&指向函数指针数组的指针

    int (*pArr[])(int, int) = {0, Add, Sub, Mul, Div}; // 函数指针数组
    int (*(*pArr)[5])(int, int) = &pArr;               // *pArr是指针，指向数组个数为5的 函数指针类型 数组的地址