精华内容
下载资源
问答
  • C++ 指针中:指针数组 指向指针数组指针 指向指针指针
    2021-11-15 16:28:24

    指针数组:存储指针的数组

    *pa[n] //an array of pointers

    注意这里[]优先级高于*,因此pa是一个包含三个指针的数组 。

     指向指针数组的指针

    *(*pd)[n] //pointers to an array of pointers
    auto pd = &pa; // *(*pd)[n] = &pa;

    (*pd)让pd先于*结合,说明pd是一个指针,指向一个包含三个元素的数组。换句话说,这里将原本的数组名pa 替换为 *pd,*pd就是指针数组,(*pd)[i]就是数组元素,即指针。可以使用auto关键字自动生成指向指针数组的指针。

    指向指针的指针

    auto pc = pa; //a pointer to a pointer 
    // **pc = pa
    // pc[i] = pa[i] *pc[i] = *pa[i] using the same way

    我的理解是,对于较为复杂的表达式先找到核心成分,指针数组?指针?在此基础上,如果想定义指向XXX的指针,只需要将核心部分换成指针

    更多相关内容
  • C++对象指针 指向对象指针 在建立对象时,编译系统会为每一个对象分配一定的存储空间,以存放其成员。对象空间的起始地址就是对象指针。可以定义一个指针变量,用来存放对象指针。 如果有一个类: class ...
  • 主要介绍了C++中的指针结构体数组以及指向结构体变量的指针的用法,是C++入门学习中的基础知识,需要的朋友可以参考下
  • C++中指针指向二维数组实例详解 一维指针通常用指针表示,其指向的地址是数组第一元素所在的内存地址,如下 int ary[4][5]; int(*aryp)[5] = ary; 那么ary[4]相当于int(*aryp),以下理解如此,但参数传递需要知道...
  • 在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有 “缝隙”。以下面的二维数组 a 为例: int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 从概念上理解,a ...

    在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有 “缝隙”。以下面的二维数组 a 为例:

    int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };

    从概念上理解,a 的分布像一个矩阵:

    0   1   2   3
    4   5   6   7
    8   9  10  11

    但在内存中,a 的分布是一维线性的,整个数组占用一块连续的内存:

     C 语言中的二维数组是按行排列的,也就是先存放 a [0] 行,再存放 a [1] 行,最后存放 a [2] 行;每行中的 4 个元素也是依次存放。数组 a 为 int 类型,每个元素占用 4 个字节,整个数组共占用 4×(3×4) = 48 个字节。

    C 语言允许把一个二维数组分解成多个一维数组来处理。对于数组 a,它可以分解成三个一维数组,即 a [0]、a [1]、a [2]。每一个一维数组又包含了 4 个元素,例如 a [0] 包含 a [0][0]、a [0][1]、a [0][2]、a [0][3]。

    假设数组 a 中第 0 个元素的地址为 1000,那么每个一维数组的首地址如下图所示:

     为了更好的理解指针和二维数组的关系,我们先来定义一个指向 a 的指针变量 p:

    int (*p)[4] = a;

    括号中的 * 表明 p 是一个指针,它指向一个数组,数组的类型为 int [4],这正是 a 所包含的每个一维数组的类型。

    [ ] 的优先级高于 *( ) 是必须要加的,如果赤裸裸地写作 int *p[4],那么应该理解为 int *(p[4]),p 就成了一个指针数组,而不是二维数组指针,这在《C 语言指针数组》中已经讲到。

    对指针进行加法(减法)运算时,它前进(后退)的步长与它指向的数据类型有关,p 指向的数据类型是 int [4],那么 p+1 就前进 4×4 = 16 个字节,p-1 就后退 16 个字节,这正好是数组 a 所包含的每个一维数组的长度。也就是说,p+1 会使得指针指向二维数组的下一行,p-1 会使得指针指向数组的上一行。

    数组名 a 在表达式中也会被转换为和 p 等价的指针!

    下面我们就来探索一下如何使用指针 p 来访问二维数组中的每个元素。按照上面的定义:
    1) p 指向数组 a 的开头,也即第 0 行;p+1 前进一行,指向第 1 行。

    2) *(p+1) 表示取地址上的数据,也就是整个第 1 行数据。注意是一行数据,是多个数据,不是第 1 行中的第 0 个元素,下面的运行结果有力地证明了这一点: 

    #include <stdio.h>
    int main(){
        int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };
        int (*p)[4] = a;
        printf("%d\n", sizeof(*(p+1)));
    
        return 0;
    }

     运行结果:  16

     3) *(p+1)+1 表示第 1 行第 1 个元素的地址。如何理解呢?

    *(p+1) 单独使用时表示的是第 1 行数据,放在表达式中会被转换为第 1 行数据的首地址,也就是第 1 行第 0 个元素的地址,因为使用整行数据没有实际的含义,编译器遇到这种情况都会转换为指向该行第 0 个元素的指针;就像一维数组的名字,在定义时或者和 sizeof、& 一起使用时才表示整个数组,出现在表达式中就会被转换为指向数组第 0 个元素的指针。

    4) *(*(p+1)+1) 表示第 1 行第 1 个元素的值。很明显,增加一个 * 表示取地址上的数据。
    根据上面的结论,可以很容易推出以下的等价关系:
    根据上面的a+i == p+i
    a[i] == p[i] == *(a+i) == *(p+i)
    a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)结论,可以很容易推出以下的等价关系:

    a+i == p+i
    a[i] == p[i] == *(a+i) == *(p+i)
    a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)

     【实例】使用指针遍历二维数组。

    #include <stdio.h>
    int main(){
        int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
        int(*p)[4];
        int i,j;
        p=a;
        for(i=0; i<3; i++){
            for(j=0; j<4; j++) printf("%2d  ",*(*(p+i)+j));
            printf("\n");
        }
    
        return 0;
    }

     运行结果:

     0   1   2   3
     4   5   6   7
     8   9  10  11

    指针数组和二维数组指针的区别

    指针数组和二维数组指针在定义时非常相似,只是括号的位置不同:

    int *(p1[5]);  //指针数组,可以去掉括号直接写作 int *p1[5];
    int (*p2)[5];  //二维数组指针,不能去掉括号

    指针数组和二维数组指针有着本质上的区别:指针数组是一个数组,只是每个元素保存的都是指针,以上面的 p1 为例,在 32 位环境下它占用 4×5 = 20 个字节的内存。二维数组指针是一个指针,它指向一个二维数组,以上面的 p2 为例,它占用 4 个字节的内存。

    二级指针

    使用二级指针初始化一级指针

     

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    enum
    {
        Success,NameErr,SexErr,StrNumErr,ScoreErr
    };
    typedef struct stu
    {
        char *name;
        char *sex;
        char *strNum;
        float *score;
    }STU;
    int init(STU ** p)
    {
        *p = (STU *)malloc(sizeof(STU));//*p就是ps,申请一块空间里面存放4个不同类型的指针,将首地址赋值给ps
        //初始化一级指针,使这4个不同类型的指针都有所指向
        (*p)->name = (char *)malloc(sizeof(100));
        if((*p)->name == NULL)
            return NameErr;
        (*p)->sex = (char *)malloc(sizeof(char));
        if((*p)->sex == NULL)
            return SexErr;
        (*p)->strNum = (char *)malloc(sizeof(30));
        if((*p)->strNum == NULL)
            return StrNumErr;
        (*p)->score = (float *)malloc(sizeof(float));
        if((*p)->score == NULL)
            return ScoreErr;
        return Success;
    }
    int main(void)
    {
        STU * ps = NULL;
    
        int ret = init(&ps);
        if(ret != Success)
            return -1;
        strcpy(ps->name,"wahaha");
        *(ps->sex) = 'x';
        strcpy(ps->strNum,"语文");
        *(ps->score) = 66.5;
    
        printf("姓名:%s\n性别:%c\n科目:%s\n分数:%.2f\n",ps->name,*(ps->sex),ps->strNum,*(ps->score));
        return 0;
    }

    展开全文
  • 1.一维数组名作为函数参数传递一位数组名,就相当于该数组的首个元素的地址; 代码如下:int a[10];int *p;p=a;//p=a与p=&a[0]是等价的实例代码: 代码如下:#include<iostream>using namespace std;int main(){ int ...
  •  记住:在cout和多数C++表达式中,char数组名、指向char的指针以及用引号括起来的字符串常量都被解释为字符串第一个字符的地址.  5、无法使用string对象初始化char指针,但是string类提供了一个名为c_str的成员...
  • C++声明指向数组指针

    千次阅读 2020-10-05 18:29:20
    它为一个整型数组分配内存,并把vp声明为一个指向整型的指针,并把它初始化为指向 vector数组的第1个元素。 vector和vp具有相同的类型:指向整型的指针。 第2个声明是非法的。它正确地创建了 matrix数组,并把mp声明...

    一、问题

    下面这些声明合法吗?

    	int vector[10], *vp = vector;
    	int matrix[3][10], *mp=matrix,
    	

    二、答案

    第1个声明是合法的。它为一个整型数组分配内存,并把vp声明为一个指向整型的指针,并把它初始化为指向 vector数组的第1个元素。 vector和vp具有相同的类型:指向整型的指针

    第2个声明是非法的。它正确地创建了 matrix数组,并把mp声明为一个指向整型的指针。但是,mp的初始化是不正确的,因为matrix并不是一个指向整型的指针,而是一个指向整型数组的指针。正确的初始化方法是

    int matrix[3][10];
    int (*mp)[10] = matrix;

    三、如何声明一个指向整型数组的指针

    int(*p)[10];

    这个声明比我们以前见过的所有声明更为复杂,但它事实上并不是很难。你只要假定它是一个表达式并对它求值。下标引用的优先级高于间接访问,但由于括号的存在,首先执行的还是间接访问。所以,p是个指针,但它指向什么呢?接下来执行的是下标引用,所以p指向某种类型的数组。这个声明表达式中并没有更多的操作符,所以数组的每个元素都是整数。

    声明并没有直接告诉你p是什么,但推断它的类型并不困难——当我们对它执行间接访问操作时,我们得到的是个数组,对该数组进行下标引用操作得到的是一个整型值。所以p是一个指向整型数组的指针
    我们在声明中加上初始化后是下面这个样子

    int(*p)[10] = matrix;// 一个指针,它指向一个有10个int元素的数组

    它使p指向matrix的第1行。
    p是一个指向拥有10个整型元素的数组的指针。当你把p与一个整数相加时,该整数值首先根据10个整型值的长度进行调整,然后再执行加法。所以我们可以使用这个指针一行一行地在 matrix中移动。

    四、实例

    现在,我们来观察一个矩阵

    int matrix[3][10] ;
    ...
    Func(matrix);

    这里,参数 matrix的类型是指向包含10个整型元素的数组的指针。Func的原型应该是怎样的呢?

    我们可以使用下面两种形式中的任何一种

    void Func( int (*mat)[10])
    void Func( int mat[][10])


    在这个函数中,mat的第1个下标根据包含10个元素的整型数组的长度进行调整,接着第2个下标根据整型的长度进行调整,这和原先的 matrIx数组一样。这里的关键在于编译器必须知道第2个及以后各维的长度,才能对各下标进行求值。因此在原型中必须声明这些维的长度。第1维的长度并不需要,因为在计算下标值时用不到它。在编写一维数组形参的函数原型时,你既可以把它写成数组的形式,也可以把它写成指针的形式。

    但是,对于多维数组,只有第1维可以进行如此选择。尤其是,把Func写成下面这样的原型是不正确的

    void Func( int **mat,int row,int col)


    它把mat声明为一个指向整型指针的指针,它和指向整型数组的指针并不是一回事。

    可以进行强制转换如下调用。

    	Func((int**)matrix,3,3);

    其他实例

    在该例中,指向有 10 个 int 元素的数组的指针会被初始化为 NULL。然而,如果把合适数组的地址分配给它,那么表达式 *arrPtr 会获得数组,并且(*arrPtr)[i] 会获得索引值为 i 的数组元素。根据下标运算符的规则,表达式(*arrPtr)[i] 等同于 *((*arrPtr)+i)。因此,**arrPtr 获得数组的第一个元素,其索引值为 0。 

        int (* arrPtr)[10] = NULL;   // 一个指针,它指向一个有10个int元素的数组    
        int matrix[3][10];            // 3行,10列的数组
                                  // 数组名称是一个指向第一个元素的指针,也就是第一行的指针
        arrPtr = matrix;            // 使得arrPtr指向矩阵的第一行
        (*arrPtr)[0] = 5;       // 将5赋值给第一行的第一个元素
        arrPtr[2][9] = 6;           // 将6赋值给最后一行的最后一个元素
        ++arrPtr;                   // 将指针移动到下一行
        (*arrPtr)[0] = 7;           // 将7赋值给第二行的第一个元素

    在前文 arrPtr 的声明语句(int(*arrPtr)[10]=NULL;)中,删除其中标识符 arrPtr,就可得到 int(*)[10],即对应的数组指针类型。然而,为了提高可读性和灵活性,可以利用 typedef 为所用的类型定义一个简单的名字:

    	typedef int ARRAY_t[10];    // 定义一个“具有10个元素数组”类型名称
    	ARRAY_t  array,                     // 具有该类型的数组
    		*arrPtr;               // 一个指向该数组类型的指针
    	arrPtr = (ARRAY_t *)array;  // 使得arrPtr指向array

     参考:

    C语言数组指针和指针数组

    如何将二维数组作为函数的参数传递_manba-CSDN博客_二维数组 函数参数

    展开全文
  • ** p——指向指针指针 ...以整型指针数组为例,先定义一组指向整型的指针数组*p,再定义一组指向整形指针指针数组**p: #include<iostream> #include<iomanip> #include<string> using namesp...

    ** 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 
    

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

    展开全文
  • 指向数组指针: char *p = new char;定义指向动态分配的字符变量的指针; char *p = new char[3];定义指向动态分配的一维字符数组的指针,p指向数组首个元素的地址,即(p+1)为数组第二个元素的地址; char (*p)[3]...
  • void *p1; const char* a1 = *((const char (*)[9])p1);...char (*)[9]使p1指向一个内含9个char型元素的数组 p1就变成了数组指针。用*号解引用该指针,就变成了一级指针,从而跟a1类型相匹配了。 ...
  • C++类与对象的学习当中,有一个用来装同一个类对象数组对象数组,有一个指向对象对象成员的指针对象指针,本文重点分析的就是对象指针对象数组的各种用法及注意事项。类和对象C++ 的重要特性,它们...
  • C++对象指针数组

    2020-11-27 14:05:21
    1.指向数组指针 #include<iostream> using namespace std; class M{ public: M(){ a=b=0; } M(int i,int j){ a=i;b=j; } void print(){ cout<<a<<","<<b<<"\t...
  • C++中的数组指针和指针数组

    千次阅读 2018-12-01 12:49:22
    using namespace std; int main(){ //a) 一个整型数( An integer) int a; //b) 一个指向整型数的指针( A ... //c) 一个指向指针的的指针,它指向指针指向一个整型数( A pointer to a pointer to an ...
  • 指向多维数组指针指针变量 以二维数组为例探究多维数组指针变量。 1. 多维数组的地址 设有整型二维数组 a[3][4]如下: 0 1 2 3 4 5 6 7 8 9 10 11 它的定义为: int a[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,...
  • C++对象数组对象指针

    千次阅读 2018-10-23 19:07:59
    1.对象数组 是指每一个数组元素都是对象数组,也就是说,若一个类有若干个对象,我们把一系列的对象用一个数组来存放。对象数组的元素是对象,不仅具有数据成员,而且还有函数成员。 格式: 类名 数组名[下标...
  • C++ 指向数组指针

    千次阅读 2019-01-18 16:45:04
    C++ 指向数组指针 如果您对 C++ 指针的概念有所了解,那么就可以开始本章的学习。数组名是一个指向数组中第一个元素的常量指针。因此,在下面的声明中: double balance[50]; balance 是一个指向 &amp;balance...
  • C/C++数组指针

    2020-10-10 22:39:03
    数组指针就是指向数组的指针! 1. excample: int arr[10] = { 1,2,3 }; //那要用一个指针怎么来表示呢? int (*parr) [10] = NULL; //指向数据的首地址 parr= &arr; 这样parr表示是一个数组指针,指向...
  • int main() { Box a[3]= { Box(), Box(15,18,20), Box(16,20,26) ...说明:主函数定义对象数组a[3],并将对象数组a的首地址赋值给指针变量P,通过指针变量P的移动,让指针P分别指向a[0], a[1], a[2]的地址。
  • c++数组指针和指针数组详解

    万次阅读 多人点赞 2019-03-14 15:33:16
    数组指针可以说成是”数组的指针”,首先这个变量是一个指针,其次,”数组”修饰这个指针,意思是说这个指针存放着一个数组的首地址,或者说这个指针指向一个数组的首地址。 指针数组 首先先定义一个指针数组,既然...
  • c++数组指针和指针数组的深入理解

    千次阅读 2020-12-28 23:33:57
    一:指针数组 写法:int* p[10];//*p未用括号括起来,说明[]的优先级高,p先和[]结合成数组,在被前面的*定义为一个指针类型的数组。 顾名思义:就是一个指针类型的数组,既然是指针类型的数组,所以数组中...
  • C++ 返回指向数组指针的函数

    千次阅读 2017-04-26 23:31:33
    数组不能被拷贝,函数不能返回数组,只能返回数组指针或者引用。 理由:会造成不必要的开销。因为数组的复制将导致连续的内存读与内存写,其【时间】开销取决于数组长度,有可能会变得非常大。C语言的函数参数...
  • 对象数组的方法对数据成员进行初始化。  #include&lt;iostream&gt; using namespace std; class box { public: box(int h=10,int w=12,int len=15):height(h),width(h),length(len){} int volume...
  • C++ 对象指针数组

    千次阅读 2019-04-21 12:27:40
    typedef Student * PStudent; PStudent *stud;//Student **stud; stud=new PStudent[5];...每一维都是一个指针 for(int k=0;k<5;k++) stud[k]=new Student();//为每一维指针new一个类 代替: typedef Stu...
  • C++ 指向动态分配的指针数组指针

    千次阅读 多人点赞 2019-03-16 21:03:07
    首先介绍指向数组指针:   char *p = new char; 定义指向动态分配的字符变量的指针;   char *p = new char[3]; 定义指向动态分配的一维字符数组的指针,p指向数组首个元素的地址,即(p+1)为数组第二个元素的...
  • C++数组指针指针数组指针数组指针的声明有点绕,防止后面绕晕记不住所以记录下。 指针数组 int *ap[3]; 为啥[3]要放在这里呢?[]优先级要高于*,所以[3]表明三个元素的数组,剩下的描述元素的类型,*表明...
  • C++ 指针数组 & 指向数组指针

    千次阅读 2017-12-19 14:25:27
    参考自《C++ Primer》template void disp(T i) { cout; }int main() { int i = 0; int j = 1; int arr[2][2] = {{1,2},{3,4}}; // 长度为2的指针数组 int *p[2]; p[0] = &i;
  • 可以定义一个指针指向一个函数,还 可以定义一个指向函数的指针数组,每个元素都是一个指向函数的指针,不过,它们指向的函数的格式都是相同的。代码如下“//指向函数的指针数组 #include&lt;iostream&gt...
  • 题目要求: 建立一个对象数组,内放5个学生的数据(学号、成绩),用指针指向数组首元素,输出第1,3,5个学生的数据。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 205,660
精华内容 82,264
关键字:

c++指向对象数组的指针

c++ 订阅