【day19】指针进阶

最新推荐文章于 2024-06-11 07:17:12 发布

顽强的单细胞

最新推荐文章于 2024-06-11 07:17:12 发布

阅读量60

点赞数

分类专栏： C语言学习文章标签： c语言

本文链接：https://blog.csdn.net/qq_45727761/article/details/125949900

版权

C语言学习专栏收录该内容

26 篇文章 0 订阅

订阅专栏

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>

指针进阶

前面学习了指针的基本知识

指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
指针的大小是固定的4/8个字节（32位平台/64位平台）。
指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
指针的运算。

字符指针

指针的类型中有一种指针叫字符指针 char*

int main()
{
    char ch = 'w';
    char *pc = &ch;
    *pc = 'w';
    return 0;
}

代码 const char* pstr = “hello bit.”;
上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中

int main()
{
    const char* pstr = "hello bit.";///本质是把字符串 hello bit. 首字符的地址放到了pstr中。
    printf("%s\n", pstr);
    return 0;
}

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

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

指针数组

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组
int main() {
    int a[5] = { 12,3,45,6,6 };
    int b[] = { 2,5,7,4,6 };
    int c[] = { 3,5,2,6,2 };
    int* arr[3] = { a,b,c };
    int i = 0;
    for (i = 0; i < 3; i++) {
        int j = 0;
        for (j = 0; j < 5; j++) {
            printf("%d ", *(arr[i] + j));
            printf("%d ", arr[i][j]);//结果是一样的，这样写模拟了二维数组，但是这三个数组是独立存放的
        }
        printf("\n");
    }
    return 0;
}

数组指针

数组指针的定义:数组指针是指针

整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。

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

int (*p)[10];

解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个
指针，指向一个数组，叫数组指针。
这里要注意：[]的优先级要高于 * 号的，所以必须加上（）来保证p先和 * 结合

&数组名和数组名

int main()
{
    int arr[10] = {0};
    printf("%p\n", arr);
    printf("%p\n", &arr);
    return 0;
}//数组名和&数组名打印的地址是一样的。

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+1 相对于 &arr 的差值是40

数组指针的使用

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

void print_arr1(int arr[3][5], int row, int col)
{
    int i = 0;
    for (i = 0; i < row; i++)
    {
        int j = 0;
        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++)
    {
        int j = 0;
        for (j = 0; j < col; j++)
        {
            //printf("%d ", arr[i][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_arr2(arr, 3, 5);
    //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
    //可以数组指针来接收
    print_arr2(arr, 3, 5);  //数组名arr，表示首元素的地址  //但是二维数组的首元素是二维数组的第一行
    return 0;
}

int arr[5]; //整型数组
int *parr1[10];//整型指针的数组
int (*parr2)[10];//整型数组指针，该指针能指向一个数组，数组10个元素，每个元素类型是int
int (*parr3[10])[5];//int (*       )[5]是一个整型数组指针，

所以 int (*parr3[10])[5] 是一个存储数组指针的数组，该数组能够存放10个数组指针，每个数组指针能指向一个数组，每个数组有5个元素，每个元素是int型

数组参数、指针参数

一维数组传参

//void test(int arr[])//可以
{}
//void test(int arr[10])//这个10 没有意义
{}
void test(int* arr)//传过来的是int 型的 数组首元地址
{}
//void test2(int* arr[20])//写成指针数组可以，20可以省略
{}
void test2(int** arr)//写成二级指针可以，取一个一级指针的地址，就是二级指针
{}
int main()
{
    int arr[10] = { 0 };
    int* arr2[20] = { 0 };//整型指针数组
    test(arr);//一维数组传参可以写成数组，数组大小可以不写，也可以写成指针，
    test2(arr2);
}

二维数组传参

void test(int arr[3][5])//可以，可以把参数写成二维数组
{}
void test(int arr[][])//不行，只能省略行，不能省略列
{}
void test(int arr[][5])//可以
{}

总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。这样才方便运算。

void test(int* arr)//不行，二维数组首元素的地址是第一行的地址，第一行是一维数组
{}
void test(int* arr[5])//不行，这样写参数部分是一个一维数组，不是指针
{}
void test(int(*arr)[5])//可以，这是一个数组指针，指针指向一个有五个元素的数组，详见上文
{}
void test(int** arr)//不行，这里传过来的不是二级指针，传过来的是一个一维数组的地址
{}
int main()
{
    int arr[3][5] = { 0 };
    test(arr);
}

一级指针传参

一级指针传参一级指针接受，参数类型相同

void print(int* p, int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d\n", *(p + i));
    }
}
void test2(char* p)
{}
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，传给函数
    char b = 'w';
    char* pb = &b;
    test2(pb);
    print(p, sz);
    return 0;
}

二级指针传参

void test(char **p)
{}
int main()
{
     char c = 'b';
     char*pc = &c;
     char**ppc = &pc;
     char* arr[10];
     test(&pc);//传一级指针变量的地址可以
     test(ppc);//传二级指针可以
     test(arr);//传一级指针的数组可以
     return 0;
}

函数指针

数组名 != &数组名
函数名 == &函数名

void test()
{
    printf("hehe\n");
}
int main()
{
    printf("%p\n", test);
    printf("%p\n", &test);
    return 0;
}//输出的是两个地址，这两个地址是 test 函数的地址

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

void test(char * str)
{
 printf("hehe\n");
}
void (*pfun1)(char*);
void *pfun2(char*);//pfun2会先和( )结合，在被*解引用

int Add(int x, int y) {
    return x + y;
}
int main() {
    //pf是一个函数指针变量
    int (*pf)(int, int) = &Add;
    //int (*pf)(int, int) = Add;//函数名 ==  &函数名
    int ret = (*pf)(3, 5);
    printf("%d\n ", ret);
    return 0;
}

代码1 出自《C陷阱和缺陷》

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

(void ( * )( ))0 ；把0强制类型转换，被解释为一个函数的地址， * （…0）对0地址进行解引用操作 ( * (…0))()调用0地址处的函数

这个代码的意思是，调用0地址处的函数，该函数无参，返回类型是void 。

代码2

void (*signal(int , void(*)(int)))(int);
void (*)(int) signal(int ,void(*)(int));//这样写是错误的，但是为了方便理解
简化
typedef void(*pfun_t)(int); //对void(*)(int)的函数指针类型重命名为:pfun_t
pfun_t signal(int, pfun_t);

函数指针数组

把函数的地址存到一个数组中，那这个数组就叫函数指针数组，本质是数组

int (*parr[10])();

parr 先和 [ ] 结合，说明 parr是数组，数组的内容是 int (* )() 类型的函数指针。
函数指针数组的用途：转移表

int Add(int x, int y) {
    return x + y;
}
int Sub(int x, int y) {
    return x - y;
}
int main() {
    int (*pf1)(int, int) = Add;
    int (*pf2)(int, int) = Sub;
    int (*pfArr[2])(int, int) = { Add,Sub }; //这里的pfArr就是函数指针数组，可以存放同类型的函数指针
    return 0;
}

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;
}
void menu() {
    printf("*************************\n");
    printf("**  1:add       2:sub  **\n");
    printf("**  3:mul       4:div  **\n");
    printf("*************************\n");
}
int main()
{
    int x, y;
    int input = 1;
    int ret = 0;
    int(*p[5])(int x, int y) = { NULL, add, sub, mul, div }; //转移表
    while (input)
    {
        menu();
        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;
}

int main()//整型计算器   缺点功能少，代码冗余
{
    int x, y;
    int input = 1;
    int ret = 0;
    do
    {
        menu();
        printf("请选择：");
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            printf("输入操作数：");
            scanf("%d %d", &x, &y);
            ret = add(x, y);
            printf("ret = %d\n", ret);
            break;
        case 2:
            printf("输入操作数：");
            scanf("%d %d", &x, &y);
            ret = sub(x, y);
            printf("ret = %d\n", ret);
            break;
        case 3:
            printf("输入操作数：");
            scanf("%d %d", &x, &y);
            ret = mul(x, y);
            printf("ret = %d\n", ret);
            break;
        case 4:
            printf("输入操作数：");
            scanf("%d %d", &x, &y);
            ret = div(x, y);
            printf("ret = %d\n", ret);
            break;
        case 0:
            printf("退出程序\n");
            break;
        default:
            printf("选择错误\n");
            break;
        }
    } while (input);

    return 0;
}

指向函数指针数组的指针

指向函数指针数组的指针是一个指针
指针指向一个数组
数组的元素都是函数指针

void test(const char* str)
{
    printf("%s\n", str);
}
int main()
{
    //函数指针pfun
    void (*pfun)(const char*) = test;
    //函数指针的数组pfunArr
    void (*pfunArr[5])(const char* str);
    pfunArr[0] = test;
    //指向函数指针数组pfunArr的指针ppfunArr
    void (*(*ppfunArr)[5])(const char*) = &pfunArr;
    return 0;
}

回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

//实现根据传参的地址调用对应的函数
int Calc(int (*pf)(int,int)) { //把需要调用的函数名（地址）传过来，再通过指针调用这个函数，这就是回调函数
    int x, y;
    printf("输入操作数：");
    scanf("%d %d", &x, &y);
    return pf(x, y);
}
//把case语句替换为
        case 1:
            ret = Calc(add);
            printf("ret = %d\n", ret);
            break;