精华内容
下载资源
问答
  • c++指向指针的指针 **p,指向指针数组的指针数组
    千次阅读
    2019-07-03 20:05:46

    ** p——指向指针的指针

    指针是一种特殊的数据类型,也是占内存的能寻址的,这跟电脑的操作系统的位数有关,我是64位的。

    int 类型

    以整型指针数组为例,先定义一组指向整型的指针数组*p,再定义一组指向整形指针的指针数组**p:

    #include<iostream>
    #include<iomanip>
    #include<string>
    using namespace std;
    int main()
    {
        int val[5]={1,2,3,5};
        int *p[5];
        int **pp[5];
        for(int i=0;i<5;i++)
        {
            p[i]=&val[i];//一阶指针指向数组的各个元素
            pp[i]=&p[i];//二阶指针指向各个一阶指针
            cout<<p[i]<<setw(20)<<pp[i]<<setw(7)<<*p[i]<<setw(7)<<**pp[i]<<endl;
        }
        
        return 0;
    }
    

    运行结果为

    0x7ffe6cfddfe0      0x7ffe6cfde000      1      1                                                                        
    0x7ffe6cfddfe4      0x7ffe6cfde008      2      2                                                                        
    0x7ffe6cfddfe8      0x7ffe6cfde010      3      3                                                                        
    0x7ffe6cfddfec      0x7ffe6cfde018      5      5                                                                        
    0x7ffe6cfddff0      0x7ffe6cfde020      0      0
    

    可以看出,p[i]输出的是数组元素的存储地址,pp[i]输出的是指针元素的存储地址,发现一个整型数据需要4个字节的存储空间,而一个指针需要8个字节的存储空间;同时,可以知道*p[i]和**pp[i]最终指向一个地址,他们的值是一样的。二阶指针沿着一阶指针找到val[]。

    字符型指针的指针

    字符数组的每一个元素都是一个字符,占一个字节
    pp[i]输出的是一阶指针的地址,而**pp[i]输出的和*p[i]输出的是一样的,都是所指向元素的字符的值。
    对于字符数组,和整形数组在一阶指针上有所区别,如下:

    #include<iostream>
    #include<iomanip>
    #include<string>
    using namespace std;
    int main()
    {
        char val[5]={'1','2','3','5'};
        char *p[5];
        char **pp[5];
        cout<<val<<endl;
        cout<<&val<<endl;
        for(int i=0;i<5;i++)
        {
            p[i]=&val[i];//一阶指针指向数组的各个元素
            pp[i]=&p[i];//二阶指针指向各个一阶指针
            cout<<setw(7)<<p[i];//输出的p[i]与整型数组有所不同,不再是地址
            cout<<setw(20)<<pp[i];//输出一阶指针的存储地址
            cout<<setw(7)<<*p[i];
            cout<<setw(7)<<**pp[i];
            cout<<setw(20)<<static_cast<void *>(p[i])<<endl;//输出每一个元素的存储地址
            
        }
        return 0;
    }
    

    运行结果如下

    1235                                                                                                                    
    0x7ffd7b4acac3                                                                                                          
       1235      0x7ffd7b4aca60      1      1      0x7ffd7b4acac3                                                           
        235      0x7ffd7b4aca68      2      2      0x7ffd7b4acac4                                                           
         35      0x7ffd7b4aca70      3      3      0x7ffd7b4acac5  
           5      0x7ffd7b4aca78      5      5      0x7ffd7b4acac6                                                           
                    0x7ffd7b4aca80                     0x7ffd7b4acac7 
    

    可以看出,cout<<val,直接输出字符数组的内容;
    cout<<&val,输出的是字符串的首地址,也就是数组中第一个元素,第一个字符的存储地址;
    cout<<p[i],输出的是所指地址的元素及其后面的元素,直到读到\0的时候停止读取;
    cout<<pp[i],输出的是一阶指针的存储地址,每个指针占八个字节;
    cout<<*p[i]和**pp[i],输出的都是所指地址的那个元素;
    cout<<static_cast<void *>(p[i]),可以输出每一个元素的存储地址。

    指向字符串指针的指针

    和指向字符的指针用法是一样的,不同的是,一个字符串包含多个字符,占多个字节,但是
    cout<<*p[i]和**pp[i]输出的都是所指地址的字符串中第一个字符的值。
    cout<<p[i]会输出每一个字符串的值
    cout<<static_cast<void *>(p[i]),可以输出每一个字符串的存储首地址。

    #include<iostream>
    #include<iomanip>
    using namespace std;
    int main()
    {
        char *pc[5]={"happy","wife","happy","life","haha"};
        char **pcc[5];
        for(int i=0;i<5;i++)
        {
            pcc[i]=&pc[i];
            cout<<setw(7)<<pc[i];//输出的是每一个字符串的值
            cout<<setw(20)<<pcc[i];//输出一阶指针的存储地址
            cout<<setw(7)<<*pc[i];
            cout<<setw(7)<<**pcc[i];
            cout<<setw(20)<<static_cast<void *>(pc[i])<<endl;//输出每一个元素的存储地址
        }
        return 0;
    }
    

    运行结果如下

    happy      0x7fff567d6170      h      h            0x400bf7                                                           
       wife      0x7fff567d6178      w      w            0x400bfd                                                           
      happy      0x7fff567d6180      h      h            0x400bf7                                                           
       life      0x7fff567d6188      l      l            0x400c02                                                           
       haha      0x7fff567d6190      h      h            0x400c07 
    

    自己在学的过程中终于弄懂了指针在各种数据类型中的各种表示所代表的数据是什么,以上内容如有错误,欢迎评论指正哦。

    更多相关内容
  • 指向指针的指针

    万次阅读 多人点赞 2019-03-06 18:27:30
    指向指针的指针!!(能让初学者绕晕的东西) 如果一个指针变量存放的又是另一个指针变量的地址,则称这个变量为指向指针的指针变量或指向指针的指针。 定义方式: 数据类型 **变量名; int a=10; //地址...

    指向指针的指针!!(能让初学者绕晕的东西)

    如果一个指针变量存放的又是另一个指针变量的地址,则称这个变量为指向指针的指针变量或指向指针的指针。

    定义方式:   数据类型  **变量名;

     

     
    1. int a=10; //地址为&a

    2. int *p=&a; //指针地址为&p 如果是p就是a的地址

    3. int **p1=&p; //指针地址为&p1 如果是*p1就是&p</span>

    要注意这几个地址的区别,不能混淆了。

     

     

    指针运算符

    指针运算符有两种:

    • 取地址运算符&:& 是单目运算符,其结合性为自右至左,功能是取变量的地址。
    • 取内容运算符*:* 是单目运算符,其结合性为自右至左,用来表示指针变量所指的变量。在 * 运算符之后跟的变量必须是指针变量。


    需要注意的是指针运算符(*)和指针变量说明中的指针说明符(*)不是一回事。在指针变量说明中,“*”是类型说明符,表示其后的变量是指针类型,而表达式中出现的“*”则是一个运算符用以表示指针变量所指的变量。例如:

     

    #include <stdio.h>

    void main(){

    int a=5;

    int *p=&a;

    printf("%d\n", *p);

    }

    运行结果:
    5

    int *p=&a;表示指针变量p取得了整型变量a的地址,printf("%d\n",*p);语句表示输出变量a的值。

    赋值运算

    指针变量的赋值运算有以下几种形式。

    1) 指针变量初始化赋值。

    2) 把一个变量的地址赋予指向相同数据类型的指针变量。例如:

    int a, *pa;
    pa=&a;  //把整型变量a的地址赋予整型指针变量pa


    3) 把一个指针变量的值赋予指向相同类型变量的另一个指针变量。如:

    int a, *pa=&a, *pb;
    pb=pa;  //把a的地址赋予指针变量pb

    由于pa、pb均为指向整型变量的指针变量,因此可以相互赋值。

    4) 把数组的首地址赋予指向数组的指针变量。例如:

    int a[5], *pa;
    pa=a;  //数组名表示数组的首地址,可以赋予指向数组的指针变量pa

    也可写为:

    pa=&a[0];  //数组第一个元素的地址也是整个数组的首地址,也可赋予pa

    当然也可采取初始化赋值的方法:

    int a[5], *pa=a;

    加减算术运算(针对数组)

    对于指向数组的指针变量,可以加上或减去一个整数n。设pa是指向数组a的指针变量,则pa+n、pa-n、pa++、++pa、pa-、--pa运算都是合法的。指针变量加或减一个整数n的意义是把指针指向的当前位置(指向某数组元素)向前或向后移动n个位置。应该注意,数组指针变量向前或向后移动一个位置和地址加1或减1在概念上是不同的。因为数组可以有不同的类型,各种类型的数组元素所占的字节长度是不同的。如指针变量加1,即向后移动1 个位置表示指针变量指向下一个数据元素的首地址。而不是在原地址基础上加1。例如:

    int a[5],*pa;
    pa=a;  //pa指向数组a,也是指向a[0]
    pa=pa+2;  //pa指向a[2],即pa的值为&pa[2]

    指针变量的加减运算只能对数组指针变量进行,对指向其它类型变量的指针变量作加减运算是毫无意义的。

     


    重点(特别容易晕的地方)【示例】二维数组与指针举例。

     
     

    #include <stdio.h>

    void main(){

    //a[0]表示第一行数组,它是变量名,不是单纯的变量,a[1],a[2]同理。

    int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11}; //二维数组可以拆分成多个一维数组,C语言中允许这样拆分。

    printf(" a=%d,",a); //第一行数组的第一个数据的地址(a[0][0])

    printf(" *a=%d,",*a); //第一行数组的第一个数据的地址(a[0][0])

    printf(" a[0]=%d,",a[0]); //第一行数组的第一个数据的地址(a[0][0])

    printf(" &a[0]=%d,",&a[0]); //第一行数组的第一个数据的地址(a[0][0])

    printf(" &a[0][0]=%d\n",&a[0][0]); //第一行数组的第一个数据的地址(a[0][0])

     

    printf("a+1=%d,",a+1); //第二行数组的第一个数据的地址(a[1][0])

    printf(" *(a+1)=%d,",*(a+1)); //第二行数组的第一个数据的地址(a[1][0])

    printf(" a[1]=%d,",a[1]); //第二行数组的第一个数据的地址(a[1][0])

    printf(" &a[1]=%d,",&a[1]); //第二行数组的第一个数据的地址(a[1][0])

    printf(" &a[1][0]=%d\n",&a[1][0]); //第二行数组的第一个数据的地址(a[1][0])

     

    printf("a+2=%d,",a+2); //第三行数组的第一个数据的地址(a[2][0])

    printf(" *(a+2)=%d,",*(a+2)); //第三行数组的第一个数据的地址(a[2][0])

    printf(" a[2]=%d,",a[2]); //第三行数组的第一个数据的地址(a[2][0])

    printf(" &a[2]=%d,",&a[2]); //第三行数组的第一个数据的地址(a[2][0])

    printf(" &a[2][0]=%d\n\n",&a[2][0]); //第三行数组的第一个数据的地址(a[2][0])

    printf(" a[1]+1=%-8d,",a[1]+1); //第二行数组的第二个数据的地址(a[1][1])

    printf(" *(a+1)+1=%-8d\n",*(a+1)+1); //第二行数组的第二个数据的地址(a[1][1])

    printf("*(a[1]+1)=%-8d,",*(a[1]+1)); //a[1][1]的数据

    printf(" *(*(a+1)+1)=%-8d\n",*(*(a+1)+1)); //a[1][1]的数据

    getchar();

    }

    运行结果:

      a=2686736,     *a=2686736, a[0]=2686736, &a[0]=2686736, &a[0][0]=2686736
    a+1=2686752, *(a+1)=2686752, a[1]=2686752, &a[1]=2686752, &a[1][0]=2686752
    a+2=2686768, *(a+2)=2686768, a[2]=2686768, &a[2]=2686768, &a[2][0]=2686768
    
       a[1]+1=2686756 ,    *(a+1)+1=2686756
    *(a[1]+1)=5       , *(*(a+1)+1)=5

    总结:①a[0]是第一个一维数组的数组名和首地址,a、a[0]、*(a+0)、*a、&a[0][0]是相等的;②a+1、a[1]、*(a+1)、&a[1][0]是等同的。

     

    所以推理出:a+i,a[i],*(a+i),&a[i][0]是等同的。此外,&a[i]和a[i]也是等同的。因为在二维数组中不能把&a[i]理解为元素a[i]的地址,不存在元素a[i]。C语言规定,它是一种地址计算方法,表示数组a第i行首地址。由此,我们得出:a[i],&a[i],*(a+i)和a+i也都是等同的。另外,a[0]也可以看成是a[0]+0,是一维数组a[0]的0号元素的首地址,而a[0]+1则是a[0]的第1个元素首地址,由此可得出a[i]+j则是一维数组a[i]的j号元素首地址,它等于&a[i][j]。由a[i]=*(a+i)得a[i]+j=*(a+i)+j。由于*(a+i)+j是二维数组a的i行j列元素的首地址,所以,该元素的值等于*(*(a+i)+j)。

    展开全文
  • C语言 指针数组和指向指针的指针

    千次阅读 多人点赞 2019-05-22 16:44:29
    组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。 指针数组说明的一般形式为:类型说明符 *数组名[数组长度] 其中类型说明符为指针值所指向的变量的类型 指针数组类型表示的是多个指针(一组有...

    针对自己在学习指针知识的时候比较难理解,特意整理出来,防止后面忘了,也拿出来供大家理解

    指针数组的概念:

    一个数组的元素值为指针则是指针数组。 指针数组是一组有序的指针的集合。 指针数
    组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。

    指针数组说明的一般形式为:
    类型说明符 *数组名[数组长度]
    其中类型说明符为指针值所指向的变量的类型

    指针数组类型表示的是多个指针(一组有序指针)在一般形式中"*指针数组名"两边不能有
    括号。

    例如:
    int *pa[3]
    表示 pa 是一个指针数组,它有三个数组元素,每个元素值都是一个指针,指向整型变量。因为[]的优先级高于*运算符,所以pa[3]表示一个数组,而int*是一个指针定义,则表示pa[3]表示的是一个数组指针变量,数组里面存放的是Int类型的指针,指向int类型数据的地址。

    int main()
    {
     int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
     int *p[3]={a[0],a[1], a[2]};
     int i=0;
     //p={a[0],a[1], a[2], a[3]};
     printf("%d\n",*(*(p + 1) + 3));
     return 0;
    }

    应该注意指针数组和二维数组指针变量的区别。这两者虽然都可用来表示二维数组,但
    是其表示方法和意义是不同的。

    二维数组指针变量是单个的变量,其一般形式中"(*指针变量名)"两边的括号不可少。

    如:int (*p)[3];

    表示一个指向二维数组的指针变量。该二维数组的列数为 3 或分解为一维数组的长度为
    3。(*p)先结合成指针类型,然后与数组结合,定义数组里面的数据类型是int型,表示指针p是指向数组里面int的数据

    int main()
    {
     int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
     int (*p)[4];
     int i=0;
     p=a;
     printf("%d\n",(*p)[11]);
     printf("%d\n",p[1][2]);
     return 0;
    }

    如果一个指针变量存放的又是另一个指针变量的地址,则称这个指针变量为指向指针的
    指针变量。

    通过指针访问变量称为间接访问。由于指针变量直接指向变量,所
    以称为“单级间址”。而如果通过指向指针的指针变量来访问变量则构成“二级间址”。

                           

    定义一个指向指针型数据的指针变量:char **p;

    p 前面有两个*号,相当于*(*p)。显然*p 是指针变量的定义形式,如果没有最前面的*,那就
    是定义了一个指向字符数据的指针变量。现在它前面又有一个*号,表示指针变量 p 是指向
    一个字符指针型变量的。*p 就是 p 所指向的另一个指针变量。

    main()
    {char *name[]={"Follow me","BASIC","Great Wall","FORTRAN","Computer desighn"};//指针数组
    char **p;//定义指向指针的指针
    int i;
    for(i=0;i<5;i++)
    {p=name+i;//一个指向指针的指针指向指针数组的地址
    printf("%s\n",*p);//读取指向指针的指针指定的地址上面的值
    }
    }

    p 是指向指针的指针变量。

    main()
    {static int a[5]={1,3,5,7,9};
    int *num[5]={&a[0],&a[1],&a[2],&a[3],&a[4]};//指针数组存放数组a内容的地址
    int **p,i;
    p=num;//数组a的地址存放在指向指针的指针变量p的地址上
    for(i=0;i<5;i++)
    {printf("%d\t",**p);p++;}//**p要双重解引用,才能读取最上面的值
    }

    指针数组的元素只能存放地址。

    对于什么时候用**p,什么时候用*p,就是当指针数组里面的元素存放地址的时候,就使用**p,当指针数组里面的元素是字符串等一些值的时候,就使用*p

    展开全文
  • 指向指针的指针(int **p)

    千次阅读 2019-12-10 17:56:20
    指向指针的指针是一种多级间接寻址的形式,或者说是一个指针链。通常,一个指针包含一个变量的地址。当我们定义一个指向指针的指针时,第一个指针包含了第二个指针的地址,第二个指针指向包含实际值的位置。 一个...

    C 中指向指针的指针

    指向指针的指针是一种多级间接寻址的形式,或者说是一个指针链。通常,一个指针包含一个变量的地址。当我们定义一个指向指针的指针时,第一个指针包含了第二个指针的地址,第二个指针指向包含实际值的位置。
    在这里插入图片描述

    一个指向指针的指针变量必须如下声明,即在变量名前放置两个星号。例如,下面声明了一个指向 int 类型指针的指针:

    int **var;
    

    当一个目标值被一个指针间接指向到另一个指针时,访问这个值需要使用两个星号运算符,如下面实例所示:

    
    ```c
    #include <stdio.h>
     
    int main ()
    {
       int  var;
       int  *ptr;
       int  **pptr;
    
       var = 3000;
    
       /* 获取 var 的地址 */
       ptr = &var;
    
       /* 使用运算符 & 获取 ptr 的地址 */
       pptr = &ptr;
    
       /* 使用 pptr 获取值 */
       printf("Value of var = %d\n", var );
       printf("Value available at *ptr = %d\n", *ptr );
       printf("Value available at **pptr = %d\n", **pptr);
    
       return 0;
    }
    

    当上面的代码被编译和执行时,它会产生下列结果:

    在这里插入图片描述

    展开全文
  • 指向一个结构体的指针,也可以当做一个结构体数组来用。 可以把结构体当做 int 来看,int* 类型即可以指向一个整数,也可以指向数组。 struct T ** ptr, 说白了 就是一个结构体指针的数组,数组内都是指针,还要...
  • C_指向指针的指针

    千次阅读 2018-05-24 11:02:24
    C_指向指针的指针 怎样定义一个指向指针数据的指针变量呢? 形式可以如: char **p; p的前面有两个*号。*运算符的结合性是从右到左,因此**p相当于,显然 *p是指针变量的定义形式。如果没有最前面的*,那就是...
  • 二级指针(指向指针的指针)

    千次阅读 多人点赞 2019-09-26 11:27:52
    如果一个指针指向的是另外一个指针,我们就称它为二级指针,或者指向指针的指针。 假设有一个 int 类型的变量 a,p1是指向 a 的指针变量,p2 又是指向 p1 的指针变量,它们的关系如下图所示: 将这种关系转换为...
  • 指向指针的指针方法对n个整数排序输出。要求将排序单独写成一个函数,n和各整数在主函数中输入,最后在主函数中输出。 ```c #include<stdlib.h> #include <stdio.h> void sort_numbers(int **,int );...
  • 指向指针的指针与二维数组的区别

    千次阅读 2018-07-07 14:06:56
    int main(){ int a[2][3]={{1,2,3},{4,5,6}};... 由于p是指向指针的指针,p指向一个int *类型的变量,而数组名a表示数组首元素的地址&amp;a[0],因此p指向a[0]。然而a[0]并不是int *类型的变量,与p应...
  • 指向数组指针指向整形数的指针

    千次阅读 2019-05-09 22:02:09
    最近看书看到二维数组与指针的章节,将一个二维数组名字赋值给一个指向整形数的指针,咋看没毛病,其实还是数组与指针的概念没有理清楚,先放代码。 #include <stdio.h> int Array[1][2]={1,2}; int main...
  • 二维数组与指向指针的指针

    千次阅读 2016-06-13 11:53:31
    二维数组与指向指针的指针: 以前一直有种误解: 二维数组的是数组的数组,所以数组的首地址是指向第一个元素指针,而这个元素又是一个数组,所以把数组首地址理解为指向指针的指针。 #include void main() ...
  • 深入理解C语言指针

    万次阅读 多人点赞 2019-09-28 08:36:51
    一、指针的概念 要知道指针的概念,要先了解变量在内存中如何存储的。在存储时,内存被分为一块一块的。每一块都有一个特有的编号。而这个编号可以暂时理解为指针,就像酒店的门牌号一样。 1.1、变量和地址 先写一段...
  • 指向指针的指针”的作用和应用

    万次阅读 多人点赞 2017-03-09 16:10:13
    (1)在子函数中修改主函数传过来的指针指向(主要目的) 明显的例子: #include int find(char *s, char src, char **rt)//从s中查询出src字符所在的位置并在rt中返回。 { int i = 0; while (*(s + i)) { ...
  • 指向指针的指针的用途

    千次阅读 2017-07-19 12:08:06
    在阅读apache的源码时,发现一处使用指针的指针的案例,平时没有够多考虑指向指针的指针这个问题,今天顺便理解了一下,这里沾上apache的源码,这时apr一个很经常用的函数,就是根据字符串的中断值来获取中断值隔开...
  • /*用指向指针的指针的方法对5个字符串排序并输出*/ #include <stdio.h> #include <string.h> #define N 10 int main() { char *str[5]={"12","11","40","35","36"}; int i,j; char **p,*t; p = ...
  • 指针就是指向变量的地址 在这里插入代码片 指针常量 int * const p =&a; 特点:指针指向不可以修改,指针指向的内存的值可以修改 举例: *p = 20; p=&b; 常量指针 int a = 10; int b = 10; const int *p...
  • 指针指针指针指向的地址,还有自身的地址之间的关系有些复杂,浅谈一下自己的理解。 #include <iostream> //#include <fstream> int test(int a, int b); int main() { using namespace std; ...
  • C++ 常指针指向常量的指针

    千次阅读 2020-11-28 21:26:42
    说明:常指针指向的地址不能变,但是其所指向的地址中的值可以变。即指针本身是个常量。 举例: char testdata1, testdata2; char* const p = &testdata; // 必须赋初值 *p = 0x55; p = &testdata2; //...
  • C语言指向数组元素的指针

    千次阅读 2021-05-21 16:26:57
    指向数组元素的指针和运算法则所谓指向数组元素的指针,其本质还是变量的指针。因为数组中的每个元素,其实都可以直接看成是一个变量,所以指向数组元素的指针,也就是变量的指针指向数组元素的指针不难,但很常用...
  • 指针指向内存free后指针指向哪里

    千次阅读 2020-04-28 23:36:21
    #include"stdio.h" #include"stdlib.h" ...//现在指针指向位置是NULL ptr = (int *)malloc(10);//假设分配的内存空间地址为0x0024FF24 printf("%f",ptr); free(ptr);//现在ptr'指向的地址还是0x0024FF...
  • 文章目录C++类的对象和类的指针的区别指向地址的指针指针本身的大小指向数组的指针指针数组指向指针数组的指针多维指针数组函数参数中使用指针数组指针传址实现数组求和函数指针模仿C++ 类别函数指针数组对象指针...
  • 指向指针的指针的方法对5个字符串排序并输出
  • 数据结构指针指向问题

    千次阅读 多人点赞 2020-04-06 21:20:05
    数据结构单链表指针指向基础问题 L在数据结构中一般是作为链表头节点的指针,p=L,将P指针指向头节点。 L->next有两层含义,可以表示L的后继节点指针,又可表示L的指针域,(补充:链表每个节点分为数据域和...
  • C语言文件的定义,如何对文件进行操作,文件指针,如何定义指向文件的指针,通过文件指针对文件进行操作,文件应用举例,二进制文件相关操作,文件定位
  • 一、指向常量的指针 从名称上看简单理解:一个指向常量的指针变量(即指针指向的值不可修改),但可以更改指针指向的地址。 定义:const int *p或者int const *p int main() { int a = 10; int b = 15; int ...
  • 指向指针的指针申请动态内存

    千次阅读 2016-05-25 17:59:09
    在《高质量c编程指南》中,提到了 如果函数的参数是一个指针,那么别指望它能申请动态内存。 代码如下:#include #include void GetMemory(char *p,int num);int main() { char* stu=NULL; GetMemory(stu,100); ...
  • #define LINEMAX 20 /* 用指向指针的指针的方法对5个字符串排序并且输出 */int main(int argc, char *argv[]) { //指向指针的指针的方法对5个字符串排序 void sort(char **p); char **p,*pstr[5],st...
  • 定义数组时,要给出数组名和数组长度,数组名可以认为是一个指针,它指向数组的第 0 个元素。在C语言中,我们将第 0 个元素的地址称为数组的首地址。以上面的数组为例,下图是 arr 的指向: 数组名的本意是表示...
  • 习题 6.19 用指向指针的指针的方法对5个字符串排序并输出。 代码块: #include &lt;iostream&gt; using namespace std; void sort(char *s[], int n); int main() { char *str[5]={"zoo", &...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,280,005
精华内容 512,002
关键字:

指向指针的指针

友情链接: nmflib-master.zip