精华内容
下载资源
问答
  • 主要介绍了c++数组与指针的相关资料,帮助大家更好的理解和学习c++,感兴趣的朋友可以了解下
  • 详细讲解了指针,指针数组,数组指针,指针的指针等的应用。
  • C++数组指针指针数组、指针数组的指针的声明有点绕,防止后面绕晕记不住所以记录下。 指针数组 int *ap[3]; 为啥[3]要放在这里呢?[]优先级要高于*,所以[3]表明三个元素的数组,剩下的描述元素的类型,*表明...


    C++数组的指针、指针数组、指针数组的指针的声明有点绕,防止后面绕晕记不住所以记录下。

    指针数组

    int *ap[3];

    为啥[3]要放在这里呢?[]优先级要高于*,所以[3]表明三个元素的数组,剩下的描述元素的类型,*表明数组元素为指针,int表明指针指向int类型。所以该声明为:具有3个指向int类型的指针的数组。

    数组的指针

    int (*pa)[3];

    [3]表明为三个元素的数组,剩下的部分就是描述元素的类型。(*pi)是一个整体,表明是一个指针变量,变量名为pa。int表明元素为int类型。解释为:具有3个int类型元素的数组的指针。

    指针数组的指针

    int *(*pap)[3];

    知道指针数组的声明*ap[3],那么替换ap变量为一个指针(*apa),代入进去为*(*apa)[3]就是指针数组的指针了。
    反过来,我们将上面的(*pap)看成一个叫pa的变量名为:int *pa[3];它就是具有3个指向int类型的指针的数组,那么该数组的引用,就将pa这个变量名变为一个指针变量,替换为*pap然后代进去加上括号就是上面的声明了int *(*pap)[3];:一个具有3个指向int类型的指针的数组的指针。

    类型指针啥的太麻烦了,有点记不住,C++11版本新增的auto关键字可以省略类型的定义,让编译器来判定值的类型。

    关于CLion编辑器本地变量定义小技巧

    上面一堆指针啥类型啥的,太麻烦了。如果不适用auto关键字,想要自己显示的定义一个复杂的类型,比如"指针数组的指针类型"或者"函数指针数组的指针"的声明,还是比较费劲的。
    CLion的自动创建本地变量的功能很有用。菜单:Main menu | Refactor | Extract | Introduce Variable...可以生成本地变量。
    使用快捷键的演示如下:
    在这里插入图片描述
    使用CLion的快速创建变量的功能,很方便的就根据右值创建了左边的符合的类型变量。

    CLion设置里面keymap搜Introduce Variable可以看到你的快捷键。

    代码

    int a[3];                          //3个int类型元素的数组
    a[0]=1;
    a[1]=2;
    a[2]=3;
    int (*pa)[3] = &a;                 //3个int类型元素的数组的指针
    int *ap[3] = {&a[0], &a[1], &a[2]};//3个int类型元素的指针的数组
    int *(*pap)[3] = ≈              //3个int类型元素的指针的数组的指针
    
    展开全文
  • C++数组与指针深入剖析C++数组与指针深入剖析C++数组与指针深入剖析C++数组与指针深入剖析
  • C++数组与指针

    2011-10-24 20:09:57
    C++数组与指针全面介绍,指针的重要性不言而喻,很多程序员怕指针,越是怕用,越要去用!
  •  指针是C/C++语言的特色,而数组与指针有太多的相似,甚至很多时候,数组名可以作为指针使用。于是乎,很多程序设计者就被搞糊涂了。而许多的大学老师,他们在C语言的教学过程中也错误得给学生讲解:“数组名就是...
  • 主要介绍了C++中用new创建二维数组指针数组实例代码,非常不错,具有参考借鉴价值,需要的朋友参考下
  • c++数组指针和指针数组详解

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

    指针数组:

    指针数组可以说成是”指针的数组”,首先这个变量是一个数组,其次,”指针”修饰这个数组,意思是说这个数组的所有元素都是指针类型,在32位系统中,指针占四个字节。

    数组指针:

    数组指针可以说成是”数组的指针”,首先这个变量是一个指针,其次,”数组”修饰这个指针,意思是说这个指针存放着一个数组的首地址,或者说这个指针指向一个数组的首地址。

    指针数组

    首先先定义一个指针数组,既然是数组,名字就叫arr

    char *arr[4] = {"hello", "world", "shannxi", "xian"};
    

    arr[4]是一个定义的数组。把它对应到对应到内存中,arr是一个在栈区,有四个元素的数组,而每一个元素又是一个指针,所以说它的四个元素各占四个字节,所以变量arr的大小是16个字节。arr+1会跳过四个字节。也就是一个指针的大小 。

    数组指针

    首先来定义一个数组指针,既然是指针,名字就叫pa,要给指针加括号。

    char (*pa)[4];
    

    pa是一个指针指向一个char [4]的数组,每个数组元素是一个char类型的变量。既然pa是一个指针,存放一个数组的地址,那么在我们定义一个数组时,数组名称就是这个数组的首地址,那么这二者有什么区别和联系呢

    char a[4];
    

    数组名称和数组指针的区别

    a是一个长度为4的字符数组,a是这个数组的首元素首地址。既然a是地址,pa是指向数组的指针,那么能将a赋值给pa吗?答案是不行的!因为a是数组首元素首地址,pa存放的却是数组首地址,a是char 类型,a+1,a的值会实实在在的加1,而pa是char[4]类型的,pa+1,pa则会加4,虽然数组的首地址和首元素首地址的值相同,但是两者操作不同,所以类型不匹配不能直接赋值,但是可以这样:pa = &a,pa相当与二维数组的行指针,现在它指向a[4]的地址。

    char *p=a;   //p是指向数组首元素的指针
    

    数组名和指针虽都代表数组首元素的地址,但意义不同。把它们分别比作省政府和市政府,数组名相当于省政府,指向首元素的指针代表市政府。如陕西的省政府在西安,而西安市的市政府也在西安,两个政府都在西安,但其代表的意义完全不同。
     ①用sizeof关键字求数组所占的内存是整个数组大小,指针不是。
     ②对数组名取地址时是取得一个代表整个数组的地址,对指针取地址则不然。

    指针数组在参数传递时的使用

    指针数组常用在主函数传参,在写主函数时,参数有两个,一个确定参数个数,一个这是指针数组用来接收每个参数(字符串)的地址
    int main(int argc, char *argv[])
    不能传递整个数组过去,如果数组很大,这样内存利用率很低,所以应该传递数组的首地址,用一个指针接收这个地址。因此,指针数组对应着二级指针
    void fun(char **pp); //子函数中的形参
    fun(char *p[]); //主函数中的实参

    数组指针传参时的使用

    数组指针既然是一个指针,那么就是用来接收地址,在传参时就接收数组的地址,所以数组指针对应的是二维数组

    void fun(int (*P)[4]);   		//子函数中的形参,指针数组 
    a[3][4] = {0};              	//主函数中定义的二维数组
    fun(a);                       	//主函数调用子函数的实参,是二维数组的首元素首地址
    

    在这里插入图片描述
    sizeof(a)=12*4=48
    sizeof(p)=4 //(x64系统为8)
    当sizeof用于变量时返回这个变量占用的实际空间的大小。当sizeof用于数组名时,返回整个数组的大小(这里的大小指占用的字节数)。p是一个指针变量,这个变量占用四个字节。

    展开全文
  • C/C++ 数组指针及引用的区别 1.数组指针的区别 (1)定义 数组是一个符号,不是变量,因而没有自己对应的存储空间。但是,指针是一个变量,里面存储的内容是另外一个变量的地址,因为是变量所以指针有自己的...
  • C++数组与指针对象数组对象指针C++数组与指针对象数组对象指针
  • C++数组指针是两个十分常用且关系密切的数据结构,“数组指针指针数组”的言论一直层出不穷。从本质上讲,数组指针是不同的,数组是具有确定数量的元素,而指针只是一个标量值。但是,在某些情况下数组...

    C++中数组和指针是两个十分常用且关系密切的数据结构,“数组即指针,指针即数组”的言论一直层出不穷。从本质上讲,数组和指针是不同的,数组是具有确定数量的元素,而指针只是一个标量值。但是,在某些情况下数组和指针又能相互转换。下面,将从多个角度分析数组和指针。

    1. 数组和指针互相转换

    数组能在指定情况下转换为指针,当数组在表达式中使用时,编译器将数组名转换为一个指针常量,指向数组第一个元素的地址。

    int main()
    {
      int arr[] = {2,4,1,5,6};
      int *p1 = arr;
      int *p2 = &arr[0];
      cout << "p1:" << p1 << ", value:" << *p1 << endl;           // p1:0xffffcbd0, value:2
      cout << "p2:" << p2 << ", value:" << *p2 << endl;           // p2:0xffffcbd0, value:2
      cout << "arr:" << arr << ", value:" << arr[0] << endl;      // arr:0xffffcbd0, value:2
    
      cout << "p1+2:"  << p1+2 << ", value:" << *(p1+2) << endl;  // p1+2:0xffffcbd8, value:1
      cout << "arr+2:" << &arr[2] << ", value:" << arr[2] << endl;// arr+2:0xffffcbd8, value:1
    }

    结论:如果令int * p = arr,则p = arr = &arr[0], p+2 = arr+2 = &arr[2];

    但是,有两种情况下,数组名与指针不能混为一谈。

    第一种,数组作为sizeof操作符的参数时:

       sizeof是一个操作符(operator),其作用是返回一个对象或类型所占的内存字节数。

       sizeof(数组): 大小是数组的元素个数*元素类型所占字节数,与数组的类型信息相关,与地址信息无关;

       sizeof(指针): 大小固定,32位机器全是4个字节,64位机都是8个字节。

    int main() {
        int arr[] = {2, 4, 1, 5, 6};
        int *p = arr;
        cout << sizeof(arr) << endl;      // 20 : 5*sizeof(int)
        cout << sizeof(*arr) << endl;     // 4  : 第一个元素值的大小
        cout << sizeof(&arr) << endl;     // 8  : 第一个元素地址的大小
        cout << sizeof(arr[0]) << endl;   // 4  : 第一个元素值的大小
        cout << sizeof(&arr[0]) << endl;  // 8  : 第一个元素地址的大小
    
        cout << sizeof(p) << endl;        // 8  : 指针的大小
        cout << sizeof(*p) << endl;       // 4  : 指针所指元素值的大小
        cout << sizeof(&p) << endl;       // 8  : 指针的地址的大小
        cout << sizeof(p[0]) << endl;     // 4  : 数组第一个元素值的大小
        cout << sizeof(&p[0]) << endl;    // 8  : 数组第一个元素值的地址的大小
    }

    第二种,数组作为单目操作符&的操作数时:

      &数组: 表示取数组的地址,即数组的指针;

      &指针: 表示取指针的地址,即指针的指针。

    2. 二维数组与指针

    指针的概念其实很简单,指针难就难在与其他结构之间的牵扯,比如指针与二维数组。

    第一点,定义指向二维数组的指针:

       定义二维数组 int aa[2][5];

       由于数组名为数组的第一个元素的地址,而二维数组aa的第一个元素为长度为5的一维数组;

       因此,如果定义一个指针指向二维数组的话,该指针的长度也必须为5;

       即,int (*p)[5] = aa 或者 int (*p)[5] = &aa[0], 表示长度为5的指针数组。

    第二点,指针访问二维数组第一个元素中的值:

       首先,*p表示二维数组中第一个元素对应的值,即长度为5的一维数组,假设为a[5];

       其次,*p可看成一维数组a[5]的名,即a[5]的第一个元素的地址;

       最后,如果想取aa[0][2],则可用*(*p+2) 表示。

    int main() {
        int aa[2][5] = {{2, 4, 1, 5, 6},{1,2,3,4,5}};
        int (*p)[5] = aa;
        cout << *(*p+2)<< endl;       // 1
    }

    第三点,指针访问二维数组任意一个元素的值:

      (1)使用列指针:定义一个列指针p,让它指向二维数组的第1个元素。

    int main() {
        int aa[2][5] = {{2, 4, 1, 5, 6},{1,2,3,4,5}};
        int *p = &aa[0][0];
        cout << *(p+1*5+2)<< endl;
    }

      首先,aa[0] 相当于 int a[5], 则p=&aa[0][0]相当于p=a[0];

      其次,C语言中数组是按行优先顺序存储,而aa[i][j]前面共有i*5+j个元素,所以该二维数组的任意i行j列元素可表示为*(p+i*5+j)

     (2)使用行指针:定义一个行指针p,让它指向二维数组的第1行。

    int main() {
        int aa[2][5] = {{2, 4, 1, 5, 6},{1,2,3,4,5}};
        int (*p)[5] = aa; //也可以为p=&aa[0];
        cout << *(*(p+1)+2)<< endl;
    }

      其中* ( *(p+i)+j)表示任意一个i行j列的元素值, *(p+i)可理解为取二维数组中第i个元素的值,即a=int[5],而*(a+j)表示一维数组a的第j个元素的值。

    3. 数组作为函数参数

    当数组作为函数参数传入时,作为实参的数组将在函数调用前被转换为一个指向该数组首元素的指针。数组永远不会传递给函数处理,函数内部操作传来的数组,其实都是在操作一个指针。

    void fun(int arr[])
    {
        cout << sizeof(arr) << endl; // 8, 说明arr是指针
        cout << arr << endl;
    }
    
    int main()
    {
        int arr[3] = {3,1,2};
        cout << sizeof(arr) << endl; // 12, 说明arr是数组
        cout << arr << endl;
        fun(arr);
        return 0;
    }

    4. 数组与指针嵌套使用

    当数组和指针共同定义一个对象时,有以下两种情况:

    第一种,int *arr[5]

     即,指针的指针。

    int main()
    {
        int *arr[3];
        int a = 2;
        int b = 4;
        int c = 3;
        arr[0] = &a;
        arr[1] = &b;
        arr[2] = &c;
        cout << *arr[0] << endl; //2
        cout << *arr[1] << endl; //4
        cout << *arr[2] << endl; //3
        return 0;
    }

    第二种,int (*arr)[5]

    即,数组的指针。

    int main()
    {
        int arr[2][5] = {{2,3,1,2,3},{3,2,5,6,7}};
        int (*p)[5] = arr;
        cout << "arr[1][2]:" << *(*(p+1)+2) << endl; // arr[1][2]:5
        return 0;
    }

    5. 字符型对象与指针

    第一种,字符数组与指针

    int main()
    {
        char s[] = "hello";
        char *p = s;
        cout << p << endl;    // p = hello
        cout << *p << endl;   // *p = h
        cout << s << endl;    // s = hello
        cout << &s[0] << endl;// &s[0] = hello
        cout << s[0] << endl; // s[0] = h
    }

    C++中cout为了省去循环输出字符数组的麻烦,cout<<p<<endl;被翻译为输出p指向的字符串值,但是p指向的依然是数组第一个元素的地址。

    第二种,字符串与指针

    int main()
    {
        string s = "hello";
        string *p = &s;
        cout << p << endl;    // p = 0xffffcbd8
        cout << *p << endl;   // *p = hello
        cout << s << endl;    // s = hello
        cout << &s[0] << endl;// &s[0] = hello
        cout << s[0] << endl; // s[0] = h
    }

    由于string不是数组,因此指针p指向的是字符串s,定义指针的时候,也需要加取地址符号&。

    展开全文
  • 1.当用数组名作为函数参数时,函数的实参和形参都应为数组名(或者指针); Example1:有一个一维数组score,内放10个学生成绩,求平均成绩。 #include<iostream> using namespace std; flo...

    本文的学习内容参考:http://blog.csdn.net/wwdlk/article/details/6322843

    1.当用数组名作为函数参数时,函数的实参和形参都应为数组名(或者指针);

    Example1:有一个一维数组score,内放10个学生成绩,求平均成绩。

    #include<iostream>
    using namespace std;
    
    float average(float array[],int num) {
        int i;
        float aver, sum = array[0];
        for (i = 1; i< num; i++)
            sum = sum + array[i];
        aver = sum / num;
        return aver;
    }
    int main()
    {
        float aver;    
        int number;    
        cout << "please input number:";
        cin >> number;
        float *score = new float[number];        //动态创建一维数组score
        if (score == NULL)                        //检查内存空间是否分配完成
        {
            cout << "could not allocate.Bye..." << endl;
            exit(1);
        }
        cout << "please input secores:" << endl;
        for (int i = 0; i < number; i++)
            cin >> score[i];
        cout << endl;
        aver = average(score,number);//数组名作为函数参数
        cout << "the average score is " << aver << endl;
        system("pause");
        return 0;
    }

     说明:

    (1)用数组名称作函数参数,应该在主调函数和被调函数分别定义数组,本例中array是形参数组名,score是实参数组名,分别在其所在的函数中定义,不能只在一方定义;

    (2)实参数组与形参数组类型应该保持一致(这里都为float型);

    (3)形参数组可以不指定大小,此时可以在定义数组时,在数组名后面跟一个空的方括号;当需要在被调用函数中处理数组元素时,可以另设一个参数,传递需要处理的数组元素的个数;

    如下所示,根据不同的数组长度来处理不同的数据Demo

    #include<iostream>
    using namespace std;
    float average(float array[], int n) {
        int i;
        float aver, sum = array[0];
        for (i = 1; i<n; i++)sum = sum + array[i];
        aver = sum / n;
        return aver;
    }
    
    void main() {
        float score_1[5] = { 98.5,97,91.5,60,55 };
        float score_2[10] = { 67.5,89.5,99,69.5,77,89.5,76.5,54,60,99.5 };
        cout << "the average of class A is :" << average(score_1, 5) << endl;
        cout << "the average of class B is :" << average(score_2, 10) << endl;
        system("pause");
        return;
    }

    (4)用数组名作为函数实参的时,不是把数组元素的值传递给形参,而是把实参数组的起始地址传递给形参数组,这样两个数组就共占同一段内存单元

    2.用数组作为函数参数的集中情况(学习内容参考http://blog.csdn.net/zeusuperman1/article/details/8509287)

    #include<iostream>
    #include<vector>
    using namespace std;
    
    char s[] = "1234567890";
    int a[10] = { 0,1 };
    int b[10] = { 0,1 };
    void Display(char *c);
    void PutArray1(int *p, int length);
    void PutArray2(int p[], int length);
    void PutArray3(int p[10]);
    void PutArray4(int(&p)[10]);            
    void PutArray5(vector<int> vec);          //向量作为函数参数
    
    void main()
    {
        char q;
        vector<int> vector(10,1);
        cout << "这个是在主函数中对数组长度的测试:" << sizeof(s) << endl;
        Display(s);
        cout << "-------------------------------" << endl;
        PutArray1(a, 10);
        PutArray2(a, 10);
        PutArray3(a);
        PutArray4(b);
        PutArray5(vector);
        system("pause");
        return;
    }
    void Display(char *c)
    {
        cout << "这个是在子函数中对数组长度的测试:" << sizeof(c) << endl;
    }
    void PutArray1(int *p, int len)
    {
        int length1 = sizeof(p);
        cout << "第一种方法的输出:" << endl;
        cout << "第一种方法数组的长度为:" << length1 << endl;
        for (int i = 0;i < length1;i++)
        {
            cout << p[i] << " ";
        }
        cout << endl;
    }
    void PutArray2(int p[], int len)
    {
        int length = sizeof(p);
        cout << "第二种方法的输出:" << endl;
        cout << "第二种方法数组的长度为:" << length << endl;
        for (int i = 0;i < length;i++)
        {
            cout << p[i] << "  ";
        }
        cout << endl;
    }
    void PutArray3(int p[10])
    {
        int length = sizeof(p);
        cout << "第三种方法的输出:" << endl;
        cout << "第三种方法数组的长度为:" << length << endl;
        for (int i = 0;i < length;i++)
        {
            cout << p[i] << "  ";
        }
        cout << endl;
    }
    void PutArray4(int(&p)[10])
    {
        int length = sizeof(p);
        cout << "第四种方法的输出:" << endl;
        cout << "第四种方法数组的长度为:" << length << endl;
        for (int i = 0;i < length;i++)
        {
            cout << p[i] << "  ";
        }
        cout << endl;
    }
    
    void PutArray5(vector<int> vec)
    {
        vector<int>::iterator begin_iter = vec.begin();
        vector<int>::iterator end_iter = vec.end();
        int size = vec.size();
        cout << "第五种方法的输出:" << endl;
        cout << "第五种方法数组的长度为:" << size << endl;
        cout << "下面这种方法是采用向量遍历的方法遍历数组:" << endl;
        for (vector<int>::iterator iter = begin_iter;iter != end_iter;iter++)
        {
            cout << *iter << "  ";
        }
        cout << endl;
        cout << "下面这种方法是采用普通遍历数组的方法遍历数组:" << endl;
        for (int i = 0;i < size;i++)
        {
            cout << vec[i] << "  ";
        }
        cout << endl;
    }

    result:

     

    总结:

    (1)在这里,int *arrint arr[]含义相同,编译器自动将 int arr[]替换为int *arr,所以这也解释了上面在主函数和子函数中利用数组名求数组长度会得到不同结果的原因。这种情况只有在数组作为函数参数进行传递时才会发生;

    (2)在子函数中无法直接获得作为参数的数组的长度,因此数组的长度必须在函数中作为参数进行传递;

    转载于:https://www.cnblogs.com/runningRain/p/5930806.html

    展开全文
  • 本文首先给出 指针相关概念 的预备知识, 即,指针的四个概念 相关符号 表示。而后,给出 各个 指针的 相关声明方式 。最后 ,本文给出 4 个 指针 相关概念的联合实例 输出。
  • 主要介绍了C++中的指针结构体数组以及指向结构体变量的指针的用法,是C++入门学习中的基础知识,需要的朋友可以参考下
  • c++指针与数组

    2019-10-23 14:24:23
    c++指针与二维数组: 注意:上面的代码int*pLine[3]的理解方式是从右向左理解:首先知道定义的是一个大小为3的数组,这个数组的名字叫做pLine,然后知道数组中存放的是指向int的指针。也就是我们的名为pLine的...
  • 数组与指针的艺术.doc

    2010-12-28 10:56:57
    数组与指针的艺术 数组与指针的艺术
  • 数组不是指针数组名的值是一个指针常量。 ...在c/c++中,array[2],2[array]是一样的,源自于同样的 *(array +2)的指针形式写法   多维数组(从二维数组说起) *(*(p+i)+j)//是p[i][...
  • C++学习通数组与指针

    2021-01-14 13:12:17
    题库练习,内含解析
  • c++数组指针遍历

    2020-11-18 12:05:48
    int i = sizeof(p)/sizeof(char*);// 计算zhi数组长度, for (int j = 0; j<i ; ++j) { cout << p[j] << endl; //打印数组内容dao }
  • 数组指针、指针数组与二级指针数组指针与指针数组数组指针指针数组二级指针二级指针的特性指向指针数组的数组指针与二级指针测试代码 数组指针与指针数组 数组指针是指针,意为指向数组的指针; 指针数组是数组,意...
  • C/C++数组指针详解

    万次阅读 多人点赞 2013-06-13 16:16:56
    /****************************************************************/ ...数组指针(行指针) char (*c)[64]; char (*c)[64]; 不改变 指针的指针 char **c; char **c; 不改变 ...
  • 主要介绍了C++指针数组、数组指针、数组名及二维数组技巧汇总,对于深入理解C++数组与指针来说非常重要,需要的朋友可以参考下
  • 概念 数组是用于储存多个相同类型数据的集合 指针则存放值的地址,指针名表示的是地址...数组指针:就是指针,指向一个数组,如: int (*arr)[8] 传参 数组作为参数时,数组名退化为常量指针,传数组首元素的地址 ...
  • 一、题目 下面代码会输出() int main(){ int a[4]={1,2,3,4}; int *ptr=(int*)(&amp;...本题主要考察对于数组指针的认识,指针加一的能力由类型决定,即对一个指针加一的结果是对该指针...
  • 数组指针指的是指向数组的指针。 1 指针数组 指针数组中的每个元素都是指针,而多维数组是数组的数组。因此,指针数据多维数组类似。指针数组归根到底也属于数组,因此,其定义的方式为 (类型名) 标识符 ...
  • C++中二维数组与指针

    2019-03-19 11:33:17
    C++中所说的多维数组实际上是数组数组,例如 int ia[3][4] = {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9 ,10, 11}}; 此时ia实际上是一个包含3个元素的数组,而每个元素又是一个包含4个整型类型的数组。 2 指向数组的...
  • C++ 数组指针学习总结

    千次阅读 2013-11-11 15:24:25
    数组 定义及其初始化 1、数组的维数必须用值大于等于1的常量表达式定义(包括:整型字面值常量、枚举常量、用常量表达式初始化的整型const对象),非const变量以及到运行阶段才知道其值的const变量都不能用于定义...
  • 4. 学习使用指针访问数组的方法,掌握指针与数组的对应机制,学习使用指针访问字符串的方法。 5. 学习C++中字符型数组与字符串之间的联系,学习关于字符型数组定义的一些特别的知识点。 实验内容 1. 定义一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 299,301
精华内容 119,720
关键字:

c++数组与指针

c++ 订阅
友情链接: coded__kifgram.zip