C语言指针

Posted 2022-12-15 fengzi759

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C语言指针相关的知识，希望对你有一定的参考价值。

关于内存
- 存储器：存储数据器件
- 外存
  - 外存又叫外部存储器，长期存放数据，掉电不丢失数据
  - 常见的外存设备：硬盘、flash、rom、u盘、光盘、磁带
- 内存
  - 内存又叫内部存储器，暂时存放数据，掉电数据丢失
  - 常见的内存设备：ram(单片机)、DDR
  - 物理内存：实实在在存在的存储设备
  - 虚拟内存：操作系统虚拟出来的内存
  - 32 bit 32根
  - 0x00 00 00 00
  - 0xff ff ff ff
  - 操作系统会在物理内存和虚拟内存之间做映射
  - 再32位系统下，每个进程（运行着的程序）的寻找范围是4G，0x00 00 00 00
  - 再写应用程序的，咱们看到的都是虚拟内存
  - 再运行程序的时候，操作系统会将虚拟内存进行分区
    - 堆
      - 再动态申请内存的时候，再堆里开辟内存
    - 栈
      - 注意存放局部变量（再函数内部，或复合语句内部定义的变量）
    - 静态全局区
      - 未初始化的静态全局区
        
        静态变量(定义变量的时候，前面加static 修饰），或全局变量，没有初始化的，存在此区
      - 初始化的静态全局区
        
        全局变量，静态变量，赋过初值的，存放在此区
    - 代码区
      - 存放咱们的程序代码
    - 文字常量区
      - 存放常量的
    - 内存以字节为单位来存储数据的。
指针的相关概念
- 操作系统给每个存储单元分配了一个编号，从0x00 00 00 00 ~0xff ff ff ff
  - 这个编写咱们称之为地址
  - 指针就是地址
  - 指针变量：是个变量，是个指针变量，即这个变量用来存放一个地址编号
  - 再32位平台下，地址总线是32位的，所以地址是32位编号，所以指针变量是32位的4个字节
  - 注意
    - 无论你的指针是什么样子类型的指针，都只有4个字节大小
    - 但是对应类型的指针变量，只能存放对应类型的变量的地址
    - 举例：整型的指针变量，只能存放整型变量的地址
    - 扩展
      - 字符变量 char ch； ch占一个字节，它有一个地址编号，这个地址编号就是ch的地址，整型变量 int a； a 占4个字节，它占有4个字节的存储单元，有4个地址编号
指针的定义方法
- 简单的指针
  - 数据类型 * 指针变量名；
  - int *p；//定义了一个指针变量p
  - 在定义指针变量的时候 * 是用来修饰变量的，说明变量p是个指针变量
  - 变量名是p
- 关于指针的运算符
  - & 取地址、*取值
- 列子 int num；p=&num； num = *p；
  - p保存了 num 的地址，也可以说p指向了num
  - num = *p；//注意：在调用的时候 * 代表取值得意思，* p就相当于p指向的变量
- 扩展：如果在一行中定义多个指针变量，每个指针变量前面都需要加*来修饰
- int* p，*q；//定义了两个整型的指针变量p，q
- int * p，q；//定义了一个整型指针变量p，一个整型变量q
- 如果指针没有赋初值，它的值就是随机的，也就是个野指针
指针的分类
- 按指针指向的数据的类型来分
- 字符指针
  - 字符型数据的地址
  - char *p;//定义了一个字符指针变量，只能存放字符型数据的地址编号
  - char ch； p = &ch；
- 短整型指针
  - short int*p;//定义了一个短整型的指针变量p，只能存放短整型变量的地址
  - short int a; p = &a;
- 整型指针
  - int *p; //定义了一个整型的指针变量p，只能存放整型变量的地址
  - int a； p =&a;
  - 注意：多字节变量，占多个存储单元，每个存储单元都有地址编号，c语言规定，存储单元编号最小的那个编号，是多字节变量的地址编号
- 长整型指针
  - long int*p;//定义了一个长整型的指针变量p，只能存放长整型变量的地址
  - long int a; p = &a;
- float 型的指针
  - float *p；//定义了一个float型的指针变量p，只能存放float型变量的地址
  - float a； p = &a；
- double型的指针
  - double *p; //定义了一个double形的指针变量p，只能存放doube型变量的地址
  - double a; p =&a;
- 函数指针
- 结构体指针
- 指针的指针
- 数组指针
- 总结：无论什么类型的指针变量，在32位系统下，都是4个字节，只能存放对应类型的数据编号
指针和变量的关系
- 指针可以存放变量的地址编号
  - 直接通过变量的名称
    - int a； a = 100；
- 可以通过指针变量来引用变量
  - int *p；//在定义的时候， *不是取值的意思，而是修饰的意思，修饰p是个指针
  - p = &a；//取a的地址给p赋值，p保存了a的地址，也可以说p指向了a
  - *p = 100；//在调用的时候 *是取值的意思， *指针变量等价于指针指向的变量
- 注：指针变量在定义的时候可以初始化
  - int a；
  - int *p = &a; //用a的地址，给p赋值，因为p是指针变量
- 指针就是用来存放变量地址的
- *+指针变量就相当于指针指向的变量
- 扩展:
  - 对应类型的指针，只能保存对应类型数据的地址
  - 如果想让不同类型的指针相互赋值的时候，需要强制类型转换
  - void*p; 通用指针，即可以指向任何类型
- 注意：
  - *+指针取值，取几个字节，由指针类型决定的，指针为字符指针则取一个字节，指针为整型指针则取4个字节，指针为double型指针则取8个字节
  - 指针++ 指向下个对应类型的数据
    - 字符指针++，指向下个字符数据，指针存放的地址编号加1
    - 整型指针++，指向下个整型数据，指针存放的地址编号加4
指针和数组元素之间的关系
- 变量存放在内存中，有地址编号，咱们定义的数组，是多个相同类型的变量的
- 每个变量都占内存空间，都有地址编号
- 指针变量当然可以存放数组元素的地址
  - 举例
    - int a[10];
    - int *p; p =&a[0]; //指针变量p保存了数组a中第0个元素的地址，即a[0]的地址
- 数组元素的引用方法
  - 方法1：数组名[下标]
    - int a[10]; a[2] = 100;
  - 方法2 指针名加下标
    - int a[10];
    - int *p; p =a;
    - p[2] = 100;// 因为p和a等价
  - 补充：c语言规定：数组的名字就是数组的首地址，即第0个元素的地址
  - 注意：p和a的不同,p是指针变量，而a是个常量。所以可以用等号给p赋值，但不能给a赋值
  - 方法3 通过指针运算符加取值的方法来引用数组的元素
    - int a[10]; int *p;
    - p = a; *(p+2)=100;//也是可以的等价于a[2]=100
    - 解释：p是第0个元素的地址，p+2是a[2]这个元素的地址
    - 对第二个元素的地址取值即a[2]
- 指针的运算
  - 指针可以加一个整数，往下值几个它指向的变量，结果还是个地址
    - 前提：指针指向数组的时候，加一个整数才有意义
    - 举例
      - int a[10];
      - int *p;
      - p =a;
      - p+2;//p是a[0]的地址，p+2是a[2]的地址
      - 假如 p保存的地址编号是2000的话，p+2代表的地址编号是2008
  - 两个相同类型指针可以比较大小
    - 前提：只有两个相同类型的指针指向同一个数组的元素的时候，比较大小才有意义
    - 指向前面元素的指针，小于指向后面元素的指针
      - 举例
        
        int a [10];
        
        int *p, *q,n;//如果在一行上定义多个指针变量的，每个变量名前面加 *
        
        p = &a[1]; q = &a[6];
        
        if(p<q)
        
        printf("p<q \n");
        
        else if(p>q)
        
        printf("p>q \n");
  - 两个相同类型的指针可以做减法
    - 前提：必须是两个相同类型的指针指向同一个数组的元素的时候，做减法才有意义
    - 做减法的结果是，两个指针指向的中间有多少个元素
      - 举例
        
        int a[10];
        
        int *p, *q;
        
        p = &a[0]; q = &a[3];
        
        printf("%d\n",q-p);
  - 两个相同类型的指针可以相互赋值
    - 注意：只有相同类型的指针才可以相互赋值(void *类型的除外)
    - int *p; int *q;
    - int a;
    - p = &a; //p保存a的地址，p指向了变量a
    - q = p; //用p给q赋值，q也保存了a的地址，指向a
    - 注意：如果类型不相同的指针要想相互赋值，必须进行强制类型转换
    - 注意：c语言规定数组的名字，就是数组的首地址，就是数组第0个元素的地址
      - int *p；
      - int a[10];
      - p = a; p =&a[0];//这两种赋值的方法是等价的
指针数组
- 指针和数组的关系
  - 指针可以保存数组元素的地址
  - 可以定义一个数组，数组中有若干个相同类型指针变量，这个数组被称为指针数组
- 指针数组的概念
  - 指针数组本身是个数组，是个指针数组，是若干个相同类型的指针变量构成的集合
- 指针数组的定义方法
  - 类型说明符 * 数组名[元素个数];
  - int *p[10];//定义了一个整型的指针数组p，有10个元素p[0]~p[9]
  - 每个元素都是int*类型的变量
  - int a； p[1] = &a;
  - int b[10]; p[2] = &b[3];
  - p[2] 和 *(p+2) 是等价的，都是指针数组中的第2个元素
- 指针数组的分类
  - 字符指针数组 char *p[10]、短整型指针数组、整型的指针数组、长整型的指针数组、float型的指针数组、double型的指针数组
  - 结构体指针数组、函数指针数组
- 指针的指针
  - 指针的指针，即指针的地址
    - 咱们定义一个指针变量本身指针变量占4个字节，指针变量也有地址编号
    - n级指针只能存放n-1级指针的地址编号
- 字符串和指针
  - 字符串的概念
    - 字符串就是以‘\0‘结尾的若干的字符的集合
  - 字符串的存储形式：数组、字符串指针、堆
    - char string[100] = "I love C!"
      - 定义了一个字符数组string用来存放多个字符，并且用"I love C!"给string数组初始化，字符串“I love C!” 存放在string中
    - char *str = “I love C！”
      - 定义了一个指针变量str，只能存放字符地址编号，
      - 所以说 I love C！这个字符串中的字符不能存放在str指针变量中
      - str只是存放了字符I的地址编号，“I love C！”存放在文字常量区
      - 要用循环的方式去打印这个字符串%c格式输出也能直接用%s输出,直接传字符串的地址
    - char *str = (char *)malloc(10 *sizeof(char));//动态申请了10个字节的存储空间，首地址给str赋值
      - strcpy(str,“I love C”)//将字符串 “I love C！”拷贝到str指向的内存里
    字符数组
    - 在内存（栈、静态全局区）中开辟了一段空间存放字符串
    字符串指针
    - 在文字常量区开辟了一段空间存放字符串，将字符串的首地址付给str
    堆
    - 使用malloc函数在堆区申请空间，将字符串拷贝到堆区
    1. 注意
      - 可修改性
        
        栈和全局区内存中的内容是可修改的
        
        char str[100] = "I love C";
        
        str[0] = ‘y‘; //正确可以修改的
        
        文字常量区里的内容是不可修改的
        
        char *str = "I love C!";
        
        *str = ‘y‘; //错误，i存放在文字常量区，不可修改
        
        堆区的内容是可以修改的
        
        char *str=(char *)malloc(10 *sizeof(char));
        
        strcpy(str,"i love c");
        
        *str = ‘y‘;//正确，可以，因为堆区内容是可修改的
      - 注意：str指针指向的内存能不能被修改，要看str指向哪里，
      - str指向文字常量区的时候，内存里的内容不可修改
      - str指向栈、堆、静态全局区的时候，内存的内容是可以修改
    2. 初始化
      - 字符数组、指针指向的字符串：定义时直接初始化
      - char buf_aver[] = "hello world";
      - char*buf_point = "hello world";
      - 堆中存放的字符串不能初始化，只能使用strcpy,scanf赋值
      - 举例
        
        char*buf_heap;
        
        buf_heap = (char*)malloc(15);
        
        strcpy(buf_heap,"hello world");
        
        scanf("%s",buf_heap);
      - 使用时赋值
        
        字符数组：使用scanf或者strcpy
        
        buf_aver = "hello kitty";//错误，因为字符数组的名字是个常量
        
        strcpy(buf_aver,"hello kitty");//正确
        
        scanf("%s",buf_aver);//正确
        
        指向字符串的指针
        
        buf_point = "hello kitty";//正确 buf_point 指向另一个字符串
        
        strcpy(buf_point,"hello kitty");//错误，只读，能不能复制字符串到buf_point指向的内存里，取决于buf_point指向哪里如果buf_point 指向文字常量区就不能用strcpy
    3. 数组指针(一般配合多维数组使用)
      - 二维数组
        
        二维数组，有行，有列.二维数组可以看出有多个一维数组构成的，是多个一维数组的集合，可以认为二维数组的每一个元素是一个一维数组
        
        列子
        
        int a[3] [5];
        
        定义了一个3行5列的一个二维数组
        
        可以认为二维数组a由3个一维数组构成，每个元素是一个一维数组
        
        回顾
        
        数组的名字是数组的首地址，是第0个元素的地址，是个常量，数组名字加1指向下个元素
        
        二维数组a中，a+1指向下个元素，即下一个一维数组，即下一行
        
        数组指针的概念
        
        本身是个指针，指向一个数组，加1跳一个数组，即指向下个数组
        
        数组指针的定义方法
        
        指向的数组的类型 (*指针变量名) [指向的数组的元素个数]
        
        int (*p)[5];//定义了一个数组指针变量p，p指向的是整型的有5个元素的数组
        
        p+1 往下指5个整型，跳过一个有5个整型元素的数组
        
        数组指针和指针数组的区别
        
        int(*p)[5];//数组指针
        
        本身是个指针变量，p占4个字节，用来保存数组的地址
        
        int *p[5];//指针数组
        
        本身是个数组，是由5个int*类型的指针元素构成的指针数组
        
        数组指针的用法
        
        具体有例子
        
        各种数组指针的定义
        
        一维数组指针,加1后指向下个一维数组
    - int(*p)[5];
      - 配合每行有5个int型元素的二维数组来用
      - int a[3] [5]
      - p =a;
      - 二维数组指针，加一后指向下个二维数组
        
        int(*p)[4] [5];
        
        配合三维数组来用，三维数组中由若干个4行5列二维数组构成
        
        int a [3] [4] [5]
        
        p = a;
        
        这些三维数组，有个共同的特点，都是有若干个4行5列的二维数组构成
      - 三维数组指针加1后指向下个三维数组
        
        int(*p)[4] [5] [6]
        
        p+1 跳一个三维数组
        
        配合四维数组来使用，四维数组中由若干个[4] [5] [6] 三维数组构成
        
        int a [7] [4] [5] [6]
      - 四维数组指针加1后指向下个四维数组，以此类推。。。
      - 注意：
        
        容易混淆内容
        
        指针数组:是个数组，有若干个相同类型的指针构成的集合
        
        int *p[10];
        
        数组p有10个int*类型的指针变量构成，分别是 p[0]~p[9]
        
        数组指针：本身是个指针，指向一个数组，加1跳一个数组
      - 数组名字取地址：变成数组指针
        
        一维数组名字取地址，变成一维数组指针，即加1跳一个一维数组
        
        int a [10];
        
        a+1 跳一个整型元素，是a[1]的地址
        
        a和a+1 相差一个元素，4个字节
        
        &a 就变成了一个一维数组指针，是int(*p)[10]类型的
        
        (&a)+1 和&a 相差一个数组即10个元素即40个字节
        
        在运行程序时，大家会发现a和&a所代表的地址编号是一样的，即它们指向同一个存储单元，但是a和&a指针类型不同
      - 数组名字和指针变量的区别：
        
        int a[10]; int*p; p =a;
        
        相同点
        
        a是数组的名字，是a[0]的地址，p=a即p也保持了a[0]的地址，即a和p都指向a[0]，所以在引用数组的时候，a和p等价
        
        引用数组元素回顾
        
        a[2]、*(a+2) 、p[2]、 * (p+2)都是对数组a中a[2]元素的引用
        
        不同点
        
        a是常量、p是变量可以用等号‘=‘给p赋值，但是不能用等号给a赋值
        
        对a取地址，和对p取地址结果不同
        
        因为a是数组的名字，所以对a取地址结果为数组指针
        
        p是个指针变量，所以对p取地址(&p) 结果为指针的指针
      - 多维数组中指针的转换
        
        在二维数组中，行地址取*不是取值得意思，而是指针降级得意思，由行地址(数组指针)变成这一行第0个元素得地址，取 *前后还是指向同一个地方，但是指针得类型不一样了
      - 指针和函数的关系
        
        指针作为函数的参数
        
        咱们可以给一个函数传一个整型、字符型、浮点型的数据，也可以给函数传一个地址
        
        列如
        
        int num;
        
        scanf("%d",&num);
        
        函数传参：
        
        传数值
        
        void swap (int x, int y)
        
        int temp;
        
        temp =x;
        
        x =y;
        
        y =temp;
        
        int main()
        
        int a= 10,b=20;
        
        swap(a,b);
        
        printf("a=%d b=%d\n",a,b);//a=10 b =20
        
        实参：调用函数时传的参数
        
        形参：定义被调函数时，函数名后边括号里的数据
        
        结论：给被调函数传数值，只能改变被调函数形参的值，不能改变主调函数实参的值
        
        传地址
        
        void swap (int *p1, int *p2)
        
        int temp;
        
        temp =*p1;
        
        *p1= * p2; //p2指向的变量的值，给p1指向的变量赋值
        
        *p2=temp;
        
        int main()
        
        int a= 10,b=20;
        
        swap(&a,&b);
        
        printf("a=%d b=%d\n",a,b);//a=20 b =10
        
        结论: 调用函数的时候传变量的地址，在被调函数中通过*+地址来改变主调函数中的变量的值
        
        总结一句话：要想改变主函数变量的值，必须传变量的地址，而且还得通过*+地址去赋值。无论这个变量是什么类型的
        
        列如
        
        void fun(char*p)
        
        p = "hello kitty";
        
        int main()
        
        char*p = "hello world"
        
        fun(p);
        
        printf("%s \n",p); //结果为
        
        案例分析：在fun中改变的是fun函数中的局部变量p，并没有改变main函数中的变量p，所以main函数中的，变量p还是指向 hello world
        
        void fun(char**p)
        
        *p = "hello kitty";
        
        int main()
        
        char*p = "hello world"
        
        fun(&p);
        
        printf("%s \n",p); //结果为hello kitty
        
        传数组
        
        给函数传数组的时候，没法一下将数组的内容作为整体传进去，只能传数组的地址
        
        举例
        
        传一维数组的地址
        
        //void fun(int p[]) //形式1
        
        void fun(int *p) //形式2
        
        printf("%d\n",p[2]);
        
        printf("%d\n",*(p+3));
        
        int main()
        
        int a[10] = 1,2,3,4,5,6,7,8;
        
        fun(a);
        
        return 0;
        
        传二维数组的地址
        
        //void fun(int p [] [4]) //形式1
        
        void fun (int (*p)[4]) //形式2
        
        int main()
        
        int a[3] [4] =1,2,3,4,5,6,7,8,9,10,11,12;
        
        fun(a);
        
        return 0;
        
        传指针数组
        
        void fun(char **q) //char * q[]
        
        int i ;
        
        for(i = 0;i<3;i++)
        
        printf("%s\n",q[i]);
        
        int main()
        
        char *p[3] ="hello","world","kitty";//p[0] p[1] p[2] c
        
        fun(p);
        
        指针作为函数的返回值
        
        一个函数可以返回整型数据、字符数据、浮点型数据，也可以返回一个指针
        
        列如
        
        char *fun()
        
        char str[100] ="hello world";
        
        return str;
        
        int main
        
        char *p;
        
        p = fun();
        
        printf("%s\n",p);
        
        总结。返回地址的时候，地址指向的内存的内容不能释放
        
        如果返回的指针指向的内容已经被释放了，返回这个地址，也没有意义了
        
        char *fun()
        
        static char str[100] ="hello world";
        
        return str;
        
        int main
        
        char *p;
        
        p = fun();
        
        printf("%s\n",p); //hello world
        
        原因是，静态数组的内容，在函数结束后，亦然存在
        
        返回文字常量区的字符串的地址
        
        char *fun()
        
        char *str ="hello world";
        
        return str;
        
        int main
        
        char *p;
        
        p = fun();
        
        printf("%s\n",p); //hello world
        
        原因是文字常量区的内容，一直存在
        
        返回堆内存的地址
        
        char *fun()
        
        char *str；
        
        str = (char*)malloc(100);
        
        strcpy(str,"hello world");
        
        return str;
        
        int main
        
        char *p;
        
        p = fun();
        
        printf("%s\n",p); //hello world
        
        free(p);
        
        原因是堆区的内容一直存在，直到free才释放
        
        总结：返回的地址，地址指向的内存的内容得存在，才有意义
        
        指针保存函数得地址
        
        咱们定义得函数，在运行程序得时候，会将函数得指令加载到内存得代码段。所以函数也有起始地址
        
        c语言规定：函数的名字就是函数的首地址，即函数的入口地址
        
        咱们就可以定义一个指针变量，来存放函数的地址
        
        这个指针变量就是函数指针变量
        
        函数指针变量的定义方法
        
        返回值类型(*函数指针变量名)(形参列表)；
        
        int(*p)(int,int)//定义了一个函数指针变量p，p指向的函数
        
        必须有一个整型的返回值，有两个整型参数
        
        int max(int x,int y)
        
        int min(int x ,int y )
        
        可以用这个 p来存放这类函数的地址
        
        p = max;
        
        p = min;
        
        调用函数的方法
        
        通过函数的名字去调函数(最常用的)
        
        int max(int x, int y)
        
        int main()
        
        int num;
        
        num = max(3,5);
        
        通过函数指针变量去调用
        
        int max(int x, int y)
        
        int main()
        
        int num;
        
        int (*p)(int,int);
        
        p=max;
        
        num =(*p)(3,5);
        
        函数指针数组
        
        int(*p[10])(int,int);
        
        定义了一个函数指针数组，有10个元素 p[0]~p[9],每个元素都是函数指针变量，指向的函数，必须有整型的返回值，两个整型参数
        
        函数指针最常用的地方
        
        给函数传参
      - 经常混淆的指针
        
        int*a[10];
        
        这是个指针数组，数组a中有10个整型的指针变量
        
        a[0]~a[9]
        
        int (*a)[10]
        
        数组指针变量，它是个指针变量。它占4个字节，存地址编号
        
        它指向一个数组，它加1的话，指向下个数组
        
        int **p
        
        这是个指针的指针，保存指针变量的地址
        
        它经常用在保存指针的地址
        
        常见用法1
        
        int **p;
        
        int *q;
        
        p =&q;
        
        常见用法2
        
        int**p；
        
        int *q[10];
        
        分析：q是指针数组的名字，是指针数据的首地址，是q[0]的地址
        
        q[0]是个int*类型的指针。所以q[0]指针变量的地址，是int**类型的
        
        p = &q[0] 等价于 p=q
        
        int*f(void)
        
        注意：*f 没有用括号括起来
        
        它是个函数的声明，声明的这个函数返回值为int*类型的
        
        int(*f)(void)
        
        注意*f用括号括起来了， *修饰f说明，f是个指针变量
        
        f是个函数指针变量，存放函数的地址，它指向的函数，
        
        必须有一个int型的返回值，没有参数
    - 特殊指针
      - 空类型的指针(void *)
        
        char* 类型的指针指向char型的数据
        
        int* 类型的指针指向int型的数据
        
        float*类型的指针指向float型的数据
        
        回顾：对应类型的指针只能存放对应类型的数据地址
        
        void* 通用指针，任何类型的指针都可以给void* 类型的指针变量赋值
        
        int *p;
        
        void *q;
        
        q = p 是可以的，不用强制类型转换
        
        举例
        
        有个函数教 memset
        
        void *memset(void *s,int c,size_t n);
        
        这个函数的功能是将s指向的内存前n个字节，全部赋值为c
        
        Memset 可以设置字符数组、整型数组、浮点型数组的内容，所以第一个参数，就必须是个通用指针
        
        它的返回值是s指向的内存的首地址，可能是不同类型的地址。所以返回值也得是通用指针
        
        注意：void*类型的指针变量，也是个指针变量，在32位系统下，占4个字节
      - NULL
        
        空指针：
        
        char *p= NULL
        
        咱们可以认为p哪里都不指向，也可以认为p指向内存编号为0的存储单位
        
        在p的四个字节中，存放的是0x00 00 00 00
        
        一般NULL用在给指针初始化
    - main函数传参
      - int main(int argc,char*argv[])
      - int i ;
      - printf("argc=%d\n",argc);
      - for(i = 0;i<argc;i++)
      - printf("argc[%d]=%s\n",i,argv[i]);

以上是关于C语言指针的主要内容，如果未能解决你的问题，请参考以下文章