2024/06/24(11.1115)指针进阶

1.字符指针

2.数组指针

3.指针数组

4.数组传参和指针传参

5.函数指针

6.函数指针数组

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

8.回调函数

9.指针和数组一些题目的解析

字符指针 char*

我们用这种方法修改了*pch的内容从"A"变成了"a"

存储内容是什么一般指针就用什么类型.

#include <stdio.h>
#include <stdlib.h>

int main(){
    
    char ch = 'A';
    char *pch = &ch;
    *pch = 'a';

    system("pause");
    return 0;
}

字符数组和字符指针存储同样的字符串但依然有所区分.

#include <stdio.h>
#include <stdlib.h>

int main(){
    
    char str[] = "Hello World";// 字符数组,开辟了一个数组区间
    char* str1 = "Hello World";//字符指针,保存了一个地址,地址指向数组的首个元素位置

    printf("str size = %d\n",sizeof(str));
    printf("str size = %d\n", sizeof(str1));

    system("pause");
    return 0;
}

做一道小练习,猜输出结果:

#include <stdio.h>
#include <stdlib.h>

int main(){
    
    char str1[] = "Hello World";
    char str2[] = "Hello World";
    char* str3 = "Hello World";
    char* str4 = "Hello World";
    
    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");

    system("pause");
    return 0;
}

12不相同 34相同

这里比较直接用 == 所以比较的是地址

1和2开辟了两个不同的空间来存储字符串,3和4所指的字符串是常量,系统只开辟一个空间.

但是如果使用 strcmp 这个专门比较字符串内容的函数,那么12也就相等了.

例如: strcmp(str1,str2);

指针数组 数组指针又来咯

指针数组: 存放指针的数组

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

        int a, b, c;

        arr1[0] = &a;

        arr1[1] = &b;

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

        char c1, c2, c3;

        arr2[0] = &c1;

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

        char ch = 'a';

        char *pch = &ch;

        arr3[0] = &pch;

数组指针:指向数组的指针

#include <stdio.h>
#include <stdlib.h>

int main(){
    int arr[] = {10, 20, 30};
    printf("%p\n",arr);
    printf("%p\n",&arr[0]);
    printf("%p\n",&arr);

    system("pause");
    return 0;
}

它们三个输出结果都是数组的第一个元素地址

但当给它们都加1结果却不一样

#include <stdio.h>
#include <stdlib.h>

int main(){
    int arr[] = {10, 20, 30};
    printf("%p\n",arr);
    printf("%p\n",&arr[0]);
    printf("%p\n",&arr);

    int* p1 = arr;
    int* p2 = &arr[0];
    int* p3 = &arr;
    printf("%p : %p\n", p1, arr + 1);
    printf("%p : %p\n", p2, &arr[0] + 1);
    printf("%p : %p\n", p3, &arr + 1);

    system("pause");
    return 0;
}

前两个都是元素 + 1;第三个是加了这个数组它就是一个数组指针.

做区分,他俩只有一个小括号的区别:

        int* arr[]是一个指针数组

        int(*arr)[]是一个数组指针

[] 的优先级 高于 * 所以先(*p)形成指针指向[]这个数组

做一下简单回顾:

int arr[5];5个整型数组

int* parr1[10];指针数组

int(*parr2)[10];数组指针

int(*parr3[10])[5];?有10个指针的数组,指针指向一个数组

函数指针和指针函数

#include <stdio.h>
#include <stdlib.h>

int func(int a, int b){
    int ret = a + b;
    return ret;
}

int main(){
    int num = func(10, 20);
    printf("num = %d\n", num);
    //标准写法
    int(*pfunc)(int, int);//函数指针
    pfunc = &func;
     num = (*pfunc)(10, 20);
    printf("num = %d\n", num);
    //简化写法
    pfunc = func;
    num = pfunc(10, 20);
    printf("num = %d\n",num);

    system("pause");
    return 0;
}

所以指针可以指向 变量 数组 函数 结构体 文件

函数指针 int(*pfunc)(int);  指向函数的指针

               I                     I

        (返回值类型) (参数类型)

指针函数 int * pfunc(int);  返回指针的函数

小练习:

用变量a给出下面定义:

一个整型数 int a;

一个指向整型数的指针 int* a;

一个指向指针的指针,它指向的指针是一个整型数 int** a;

一个有十个整型数的数组 int a[10];

一个有十个指针的数组,该指针是指向一个整型数的 int*a[10];

一个指向有10个整型数数组的指针 int(*a)[10];

一个指向函数的指针,该函数有一个整型参数并返回一个整型数int (*a)(int);

一个有十个指针的数组,该指针指向一个函数,该函数有一个整型参数并返回一个整型数.

int (*a[10])(int);

(题目的考察点在于"变量a",之前习惯用arr *p的习惯要改2.按照要求一步一步写就能写出答案)

怎么解析一个复杂的指针状况呢?

举例:int *(*(*fun)(int*))[];

右左法则: 找到变量名,先往右看如果遇到括号就调转方向,往左解读,遇到了星号,名字和星号结合成了指针,再往右看,它是用来指向函数的,又遇到了括号,再往左看还是星号,说明函数的返回值是一个指针,又往右看,函数出来遇到方括号,说明函数返回的是一个数组数组元素有十个,再往左看发现元素类型是整型指针.

思路如上,来形容的时候要怎么说.fun是一个指针,这个指针是指向一个函数的,所指的函数为一个整型指针的参数和一个指针的返回值,返回的指针是指向一个具有10个元素的数组,每个元素的类型为整型指针. 它是返回值为数组指针的函数指针