精华内容
下载资源
问答
  • 数组声明及初始化

    2016-11-03 16:41:56
    数组Array:相同类型数据的集合就叫做数组数组长度(length),指的是数组元素的个数,元素的索引是从0开 始,最大索引==数组长度-1。 一、一维数组 1、一维数组定义: a)单独声明 格式: type[] ...

    数组Array:相同类型数据的集合就叫做数组。数组长度(length),指的是数组元素的个数,元素的索引是从0开

    始,最大索引==数组长度-1。

    一、一维数组

    1、一维数组定义:

    a)单独声明

    格式:
    type[] 数组名;声明,没有初始化
    数组名 = new type[长度];//初始化

    例如:
    int[] a;
    a = new int[5];

    注意:单独声明的数组,在初始化前不可直接对元素操作。但是,初始化的数组可以赋值给一个未初始化的数组。
    int a[];
    a[0] = 1;//错误,数组没有初始化,不能赋值

    下面的用法是可行的:
    Object[] a;//引用型数组
    Object[] b ={"abc","def"};
    a = b;
    int[] c;//原生型数组
    int[] d ={1,2};
    c = d;

    b)定义数组同时给出长度,初始化为默认值(由元素数据类型决定):

    格式:
    type[] 变量名 = new type[数组长度]
    //等价于:
    type 变量名[] =new type[数组长度]

    int[] a = new int[4];//定义一个长度为4的数组a[],各元素初始化为int型默认值0。
    a[0] = 1;//给第一个元素赋值
    a[1] = 3;

    c)声明同时初始化为给定值

    格式:type[] 变量名 = {枚举所有元素常量初始值,并用逗号分隔}
    等价于
    type[] 变量名 = new type[]{枚举所有元素初始值};//注意:type[]不能指明长度

     

    //原生数据类型数组事例

    int[] a = {1,2,3,4};//定义数组a[],a0-a3的值分别为1、2、3、4
    int[] a = new int[]{1,2,3,4};//同上

     

    //引用数据类型数组事例

    class ArrayReference{
     public static void main(String[] args){

      I[] a = new I[]{new C(),new C()};

      //上条语句等同于下列三行语句

      
      
      //调用数组元素i[0]所指对象的方法prnVal()
      i[0].prnVal();
     }
     interface I{//I接口定义
      void prnVal();
     }
     static class C implements I{//接口I的执行C类
      public void prnVal(){
      System.out.println("接口多态");
      }
     }
    }

     

    注意:枚举数组常量只能用于数组定义,如下例是错误的。
    int[] a;
    a = {1,2,3,4};//仅能用于声明


    2、array的length属性是public、final、int的,一旦确定,就不能改变它的大小。数组长度可以通过变量

    名.length获得。

    3、int[] a =new int[10],其中a是一个引用,它指向了生成的数组对象的首地址,数组中每个元素都是int类型,其中仅存放数据值本身。

    4、若数组元素是引用类型,赋值前为null,赋值后指向引用地址。例如:

    class ArrayTest{

     public static void main(String[] args){
     
      Person[] p = new Person[3];
      

      int[] pl = new int[3];
      System.out.println(pl[0]);//打印为null

      p[0] = new Person(10);//数组元素指向新建引用对象,即存储对象的地址
      p[1] = new Person(20);
      p[2] = new Person(30);
      
      for(int i =0;i<p.length;i++){
       System.out.println(p[i].age);
      }
     }
    }

    class Person{
     int age;
            public Person(int age){
      this.age = age;
     }
    }

     

    二、二维数组


    1、二维数组:是一种平面的二维结构,本质上是数组的数组。

    2、二维数组定义:

    a)单独声明,单独初始化

    格式:

    type[][] 数组名;

    例如:

    int[][] a;//声明,没有初始化

    b)固定行列长度声明,初始为默认值(由数据类型决定)。

    格式:
    type[][] 数组名 = new type[一维长度][二维长度];

    例:int[][] a = new int a[2][3];//定义一个2行3列的整型二维数组a,各元素值初始为0.

    //注意:a[行号],是一个一维数组。比如上例中a[0]和a[1]都是一维数组

    c)动态声明
    动态声明首次声明时只声明一维的长度,二维的长度动态指定(一旦指定就不可改变)。

    格式:
    type[][] 数组名 = new type[一维长度][];
    数组名[一维索引号] = new type[该行列长度];//可行原因,见b)里面的注意事项

    例如:
    int[][] a = new int[3][];
    a[0] = new int[2];//初始一维索引号为1的数组,长度为2
    a[1] = new int[3];
    a[2] = new int[1];

    注意:数组完全初始化后才能赋值,下例是错误的。
    int[][] a = new int[2][];
    a[0][1] = 1;//错误,第二维没有初始化

    d)常量初始化声明

    格式:

    type[][] 变量名 = new type[][]{{枚举行1所有元素的值},..,{枚举行n所有元素值}};//每行的元素个数不必相同。

    type[][] 变量名 =  {{枚举行1所有元素的值},..,{枚举行n所有元素值}};

     

    例如:

    //定义一个二维数组,并用指定值初始化

    int[][] a = new int[][]{{1,2},{3,4},{5,6}};//各行长度相同
    int[][] b = new int[][]{{1,2,3},{4},{5,6,7,8}};//各行长度不同


    //打印出所有元素的值
    for(int i =0;i<a.length;i++){//遍历数组的行
     for(int j =0; j<a(i).length; j++){//遍历数组的列
      System.out.println(a[i][j]);
     {
    }

    注意:如果指定了初始化值,就不能指定长度。
    int[] a = new int[2][1]{{1,2},{1}};//错误

    e)常量动态始化声明

    实际上就是上两种方法的综合使用,格式如下:

    type[][] 变量名 = new type[一维长度值][];
    变量名[一维索引] = new type[]{枚举该索引下所有数组元素的常量值};

    例如:
    int[][] a =new int[2][];
    a[0] = new int[] {1,2,3};

    注意:数组常量只能在初始化时使用。
    int[][] a =new int[2][];
    a[0] ={1,2,3,4};//错误,只能在初始化时使用

     

    小结:

    1、数组必须初始化方可使用;
    2、二维数组的有二个索引,在Java中,每一行(由一维索引表示)又是一个数组,由此可以进行二次声明。
    3、枚举数组常量只能使用在数组初始化时。在二维数组中,它不仅限于一次完整的声明也可使用在二次声明对其中一维数组的声明中。
    4、默认化初始化,由数组的类型决定,原生数据类型由JVM默认,引用类型由引用初始时为null,赋值后指向对象。

    展开全文
  • /// 声明和初始化时易出现的错误 /// &lt;/summary&gt; /// &lt;param name="args"&gt;&lt;/param&gt; static void Main(string[] args) { int[] array...
    /// <summary>
            /// 声明和初始化时易出现的错误
            /// </summary>
            /// <param name="args"></param>
            static void Main(string[] args)
            {
                int[] array =new int[5]{0,1};
            }
    

    会出现这种错误信息

    原因是声明和初始化一维数组的语句是错误的,代码“int[5]”告诉编译器数组长度是5,但是只有给其中两个元素赋初始值

    声明数组

    static void Main(string[] args)
            {
                //声明数组并初始化
                int[] arry = new int[5] { 6, 1, 2, 3, 4 };
                int[] arr1 = new int[] { 0, 1, 2, 3, 4 };//省略数组长度
                int[] arr2 ={ 0, 1, 2, 3, 4 }; //省略 new 关键字
                Console.WriteLine("数组 array 的元素个数是{0}",arry.Length);
                Console.WriteLine("数组 array 的元素个数是{0}", arr1.Length);
                Console.WriteLine("数组 array 的元素个数是{0}", arr2.Length);
    

    可以通过 “数组名.Length” 的形式来获得数组的长度
    在这里插入图片描述

    展开全文
  •  变量的定义包括一个基本数据类型(base type)和一组声明符。在同一条定义语句中,虽然基本数据类型只有一个,但是声明符的形式却可能不同。也就是说,一条定义语句可能定义出不同类型的变量。如: // i是一个int型...

    1..  概述

          变量的定义包括一个基本数据类型(base type)和一组声明符。在同一条定义语句中,虽然基本数据类型只有一个,但是声明符的形式却可能不同。也就是说,一条定义语句可能定义出不同类型的变量。如:

    	// i是一个int型数 p是一个int型指针 r是一个int型引用
    	int i=100,*p=&i,&r=i;


    2.. 指向指针的指针

        一般来说,声明符中修饰符的个数并没有限制。当有多个修饰符连写在一起时,按照其逻辑关系详加解释即可。以指针为例,指针是内存中的对象,像其他对象一样也有自己的地址,因此允许把指针的地址再存放到另一个指针当中。

        通过*的个数可以区分指针的级别,也就是说,**表示指向指针的指针,***表示指向指针的指针的指针,由此类推:

    	int iVal = 100;
    	int *pi=&iVal;			//pi指向一个int型数
    	int **ppi = &pi	;	//ppi指向一个int型的指针
        以上三者(iVal pi ppi)的关系如图所示:

        

       解引用int型指针会得到一个int型的数,同样,解引用指向指针的指针会得到一个指针。为访问最原始的iVal,需要对指针进行两次解引用。如下

    	cout<<"iVal is "<<iVal<<endl;
    	cout<<" *pi is "<<*pi<<endl;
    	cout<<" **ppi is "<<**ppi<<endl;
    3...  指向指针的引用

      引用本身不是对象(是:别名),因此不能定义指向引用的指针。但是指针是对象,所以存在对指针的引用:

    	int i=10;
    	int *p;		//声明一个int型指针
    	int *&r =p;	//r是一个对指针p的引用
    
    	r = &i;	// r引用了一个指针(r是指针p的别名),
    			//因此给r赋值&i就是令p指向i
    	*r =0;	//通过指针p的别名(引用r)改变了 i值
    	cout<<" i =" <<i<<endl;

      要理解r的类型到底是什么,应从右到左阅读r的定义,离变量名最近的符号对变量的类型有最直接的影响,因此r是个引用。声明符的其余部分用以确定引用r的类型是什么(*:表示引用r是一个指针,int :表示引用r是一个int型指针)

    4..  复杂数组声明

       和vector一样,数组能存放大多数类型的对象;例如,可以定义一个存放指针的数组。又因为数组本身是对象,所以允许定义数组的指针和数组的引用。例如下列语句:

    	//复杂数组声明
    	int arr[10];			//声明一个含10个整数的数组arr
    
    	 int *ptrs[10];			//ptrs 是含有10个整型指针的数组
    	 int &refs[10];			//错误:不存在引用的数组(引用不是对象)
    	 int (*Parrray)[10] = &arr;    //Parray指向一个含有10个整数的数组
    	 int (&parrRef)[10] = arr;		//parrRef 是一个含有10个整数的数组的引用
    
       默认情况下,类型修饰符从右到左依次绑定,所以ptrs是含有10个指向int数的数组。对于Parray ,应由内向外阅读:首先是圆括号括起来的部分,*Parray 意味着Parray是个指针,接下来观察右边,可知道Parray是个指向大小为10的数组的指针,最后观察左边,知道数组中的元素是int。所以:Parray 是一个指针,它指向一个int数组,数组中包括10个元素。同理:parrRef是个引用,它引用的对象是一个大小为10的数组,数组中的元素的类型是int。

    5..  测试结果

    #include <iostream>
    using namespace std;
    
    int main()
    {
    	int iVal = 100;
    	int *pi=&iVal;			//pi指向一个int型数
    	int **ppi = π		//ppi指向一个int型的指针
    
    	cout<<"iVal is "<<iVal<<endl;
    	cout<<" *pi is "<<*pi<<endl;
    	cout<<" **ppi is "<<**ppi<<endl;
    	
    	int i=10;
    	int *p;		//声明一个int型指针
    	int *&r =p;	//r是一个对指针p的引用
    
    	r = &i;	// r引用了一个指针(r是指针p的别名),
    			//因此给r赋值&i就是令p指向i
    	*r =0;	//通过指针p的别名(引用r)改变了 i值
    	cout<<" i =" <<i<<endl;
    	return 0;
    }




    展开全文
  • 数组

    2017-04-12 08:46:40
    数组C语言包含4种基本数据类型: 整型 浮点型 指针 聚合类型 ...一维数组声明为了声明一个一维数组,我们需要在数组名后面跟一对方括号[],方括号里面是一个整数,指定数组中的元素的个数。int valu

    数组

    C语言包含4种基本数据类型:

    • 整型
    • 浮点型
    • 指针
    • 聚合类型
      • 数组
      • 结构
      • ……

    之前的文章中,我们已经学习了前面三种基本数据类型。

    今天我们将学习聚合类型中的数组。

    数组分为两种:

    • 一维数组
    • 多维数组

    但是多维数组其实是一维数组的一种扩充,所以我们仅仅学习一维数组。

    一维数组的声明

    为了声明一个一维数组,我们需要在数组名后面跟一对方括号[],方括号里面是一个整数,指定数组中的元素的个数。

    int values[20];

    显而易见,我们声明了一个整型数组,数组包含20个整型元素。

    数组下标总是从0开始,最后一个元素的下标是元素的数目减1。

    一维数组初始化

    值得我们注意的是,与整型,浮点型,指针类型的变量初始化不同的是,数组的初始化需要一系列的值。

    这些用于初始化数组的值位于一对花括号{}中,每个值之间用逗号,分隔。

    int vector[5] = {10,20,30,40,50};

    初始化列表给出的值逐个赋值给数组的各个元素。

    所以:

    {0}. vector[0] = 10
    {0}. vector[1] = 20
    {0}. vector[2] = 30
    {0}. vector[3] = 40
    {0}. vector[4] = 50

    静态初始化和自动初始化

    变量的存储类型决定变量何时创建,何时销毁以及它的值保存多久。

    同样,数组变量的声明位置也决定着数组变量的默认存储类型。

    • 对于静态变量而言
      • 存储于静态内存中的数组只初始化一次,也就是在程序开始执行之前。
      • 链接器用包含可执行程序的文件中合适的值对数组元素进行初始化。
      • 如果数组未被初始化,数组元素的初始值将会自动设置为0。
    • 对于自动变量而言
      • 由于自动变量位于运行时堆栈中,执行流每次进入它们所在的代码块时,这类变量每次所处的内存位置可能并不相同,所以在程序开始执行前,编译器没有办法对这些位置进行初始化。所以,自动变量在默认情况下是未初始化的。
      • 如果自动变量的声明中给出了初始值,每当执行流进入自动变量声明所在的作用域时,变量就被一条隐式的赋值语句初始化。这条赋值语句需要时间和空间执行。
      • 数组的问题在于初始化列表中可能有很多值,这就可能产生很多条赋值语句。对于那些非常庞大的数组,它的初始化时间可能非常可观。

    所以,当数组的初始化局部于一个函数(或代码块)时,我们应该考虑——在程序的执行流每次进入该函数(或代码块)时,每次都对数组进行重新初始化是不是值得?

    如果不值得,那么我们应该把数组声明为static,这样数组的初始化只需在程序开始前执行一次。

    不完整的数组初始化

    按理来说,数组的初始化应该如上面所示。

    但是,在编译器中,存在几种不完整的数组初始化,且运行无误。

    int list[5] = {1,2,3,4};
    int deque[] = {1,2,3,4,5};

    对于第一条初始化语句,它将前4个初始值分别赋予list[0],list[1],list[2],list[3],而对于list[4]则默认初始化为0。

    对于第二条初始化语句,我们在声明中并没有给出数组的长度,这时编译器自动把数组的长度设置为刚好能够容纳所有初始值的长度。

    但是,我们也不能盲目的使用不完整的初始化。

    下面这两种情况,编译器在运行时则会报错或出现与我们希望情况不符合的现象:

    int list1[5] = {1,2,3,4,5,6};
    int list2[5] = {1,5};

    对于第一条声明语句,编译器直接报错。这是因为初始化值的数目和数组元素的数目并不匹配,没办法把6个数据放到5个变量中。

    对于第二条声明语句,我们本意是希望list[0] = 1,list[4] = 5。但是结果是list[0]=1,list[1] = 5,后面三个元素都为0。

    即,我们在使用不完整初始化数组时,仅仅可以省略最后几个初始值。

    字符数组初始化

    对于数组中的每个元素,除了可以存储int或float型的数值之外,我们还可以存储char型的字符。

    根据之前的知识,我们会对字符数组的初始化采用如下的方式:

    int message[] = {'h','e','l','l','o',0};

    显而易见,这种数组初始化方式比较麻瓜。

    因此,C语言标准提供了一种快速初始化字符数组的方式:

    int message[] = "hello";

    尽管初始值看上去像是一个字符串常量,但实际上并不是。

    数组与指针

    接下来,就是我们的核心——数组与指针的关系。

    我们再次研究下述声明:

    int a;
    char c;
    double d;
    int *p;
    int b[10];

    我们把前四个变量a、c、d、p称为标量,因为它们的类型单一、值单一。

    变量名 类型
    a 10 int
    c ‘H’ char
    d 3.14 double
    p &a int*

    我们把最后一个变量b称为数组,因为它是一些值的集合。

    如下图所示:

    这里写图片描述

    我们将数组名和下标一起使用,用于标识该集合中的某个特定的值。

    注意,每个特定的值都是一个标量,可以用于任何可以使用标量的上下文中环境中。

    变量名 类型
    b[0] 1 int
    b[1] 1 int
    b[2] 1 int
    b[3] 1 int
    b[4] 1 int
    b[5] 1 int
    b[6] 1 int
    b[7] 1 int
    b[8] 1 int
    b[9] 1 int

    但是,数组名b是什么类型呢?

    在C中,几乎所有使用数组名的表达式中,数组名的值是一个指针常量,也就是数组第一个元素的地址!

    数组名的值是一个指针,也就是数组第一个元素的地址!?

    大多数人看到这句话,第一反应会产生如下图所示的内存结构:

    这里写图片描述

    如图所示,数组名b是一个指针,值是数组第一个元素的地址,所以指针b应该指向数组的第一个元素。

    乍一看,这种分析非常正确。

    但是,如果数组是这种内存结构的华,那么其所占据的总内存空间是不是应该加上数组名所占据的这一块呢?

    所以,这种内存结构的示意图是错误的!

    究其原因,是由于我们忽略了句中的“的值”二字。C语言只是说数组名的值是一个指针,而没有说数组名就是一个指针。

    所以,正确的内存结构示意图应该如下图所示:

    这里写图片描述

    数组名b占据的内存空间就是数组中各个元素所占空间连接而成的总的内存空间。

    数组名的类型取决于数组元素的类型。

    • 如果数组元素的类型是int型,那么数组名就是指向int的常量指针。
    • 如果数组元素的类型是其他类型,那么数组名就是指向其他类型的常量指针。

    数组名的值是一个指针常量!?

    注意这个是指针常量,而不是指针变量。

    指针常量所指向的是内存中数组的起始位置,如果修改这个指针常量,唯一可行的操作就是把整个数组移动到内存的其他位置。但是,在程序完成链接之后,内存中数组的位置是固定的。所以当程序运行之后,再想移动数组就为时已晚了。

    因此,数组名的值是一个指针常量。

    所以,如下的操作是非法的:

    int a[10];
    int *c;
    a = c;

    数组名的值是数组第一个元素的地址!?

    这里写图片描述

    如图所示,我们可以将数组名完全看做数组第一个元素的地址。

    考虑下列代码:

    int b[10];
    int *c;
    
    c = &b[0];

    假设b[0]的地址为100。

    在执行了赋值语句之后,指针变量c的值变成100,指针c指向数组b的第一个元素。

    如下图所示:

    这里写图片描述

    由于我们可以将数组名完全看做数组第一个元素的地址,上面的赋值语句也可以改写为如下代码:

    int b[10];
    int *c;
    
    c = b;

    相当于把“类指针变量”b拷贝给了指针变量c。

    数组赋值操作

    对于一般的标量,我们可以使用赋值语句对其赋值:

    int x = y;

    很多时候,我们也希望将一个数组的所有元素赋值给另外一个数组,这时候应该怎么办呢?

    如果我们采取了和普通标量一样的方式,采用赋值操作符=,那么编译器将会报错。

    这也是很多C初学者容易犯的错误。

    int m[10];
    int n[10];
    m = n;
    /*错误*/

    这是因为数组名不能代表整个数组元素,数组名类似于指针,数组名的值的其第一个元素的地址。

    对于数组而言,如果我们希望将一个数组的所有元素赋值给另外一个数组,我们必须使用一个循环,一次复制一个元素。

    下标引用操作符[]和解引用操作符*

    首先需要声明的是,除了优先级之外,下标引用操作符[]和间接访问操作符*完全相同。

    考虑下列代码:

    int b[10];
    
    *(b + 3)是什么???

    不急,我们一步步分析:

    1. 数组名b的类型是一个指向整型的指针,所以3这个值需要根据整型值的长度进行调整。
    2. 指针加法运算的结果是另一个指向整型的指针,它指向的是数组第一个元素向后移3个整型长度的位置。
    3. 解引用操作符*访问这个位置,取得其值。

    再考虑下列代码:

    int b[10];
    
    b[3]是什么???

    对于b[3],我们之前分析过,这是一个标量,表示数组b中的第4个元素。

    所以,我们能够得到如下的等式:

    array[subscript]
    等价于
    *(array + subscript)

    那么,

    1. 在使用下标引用的地方,我们完全可以使用对等的指针表达式来代替。
    2. 在使用上面这种形式的指针表达式的地方,我们也可以使用下标表达式来代替。

    最后,我们通过一个案例,深度理解上面的内容。

    代码如下:

    int b[10] = {0,1,2,3,4,5,6,7,8,9};
    int *ap = b + 2;

    这里写图片描述

    表达式
    ap b +2 或 &b[2]
    *ap *(b + 2) 或 b[2]
    ap + 6 b + 8 或 &b[8]
    *ap + 6 b[2] + 6
    *(ap + 6) *(b + 8)或 b[8]
    ap[0] 等价于*(ap+0),即b[2]
    ap[-1] 等价于*(ap-1),即b[1]
    ap[9] 等价于*(ap+9),但是下标越界,非法!!!

    数组下标越界检查

    最早的C编译器不检查下标,同时最新的编译器依然不检查下标。

    这是由于数组和指针的密不可分的关系,导致编译器检查下标将是一项非常庞大的任务。

    所以,我们的经验是:

    • 如果下标值是从那些已知是正确的值计算得来,那么就无需检查它的值。
    • 如果一个用作下标的值是根据某种方法从用户输入的数据产生而来的,那么在使用它之前必须进行检查,确保它们位于有效的范围之内!
    展开全文
  • 数组练习

    2021-03-29 13:43:22
    1、下列数组声明的语法格式不正确的是( C ) A. int[] array; B. int array[]; C. char[]; D. String[] strArray; 2、已知一个长度为10的数组b,数组b的第三个元素表示为? ( C ) A. b[3] B. b(3) C. b[2] D. b(2) ...
  • Java 数组

    2021-03-29 13:40:47
    1.下列数组声明的语法格式不正确的是()C A. int[] array; B. int array[]; C. char[]; D. String[] strArray; 2.已知一个长度为10的数组b,数组b的第三个元素表示为? C A. b[3] B. b(3) C. b[2] D. b(2) 3.当数组...
  • java数组

    2021-03-29 09:30:31
    1.下列数组声明的语法格式不正确的是()C A. int[] array; B. int array[]; C. char[]; D. String[] strArray; 2.已知一个长度为10的数组b,数组b的第三个元素表示为?C A. b[3] B. b(3) C. b[2] D. b(2) 3.当数组...
  • Java数组

    2020-08-05 16:28:13
    1、下列数组声明的语法格式不正确的是(C) A. int[ ] array; B. int array[ ]; C. char[ ]; D. String[ ] strArray; 2、已知一个长度为10的数组b,数组b的第三个元素表示为? © A. b[3] B. b(3) C. b[2] D. b(2) 3...
  • JAVA数组

    2017-10-06 16:53:32
    数组中的元素都是同一类型。数组的长度在创建时确定,并且在创建后不变,如果需要建立存储不同类型的集合,或者要求这种数据存储结构的长度可以动态变化,可以使用Java.util包中的各种集合(Collection...数组声明语句
  • C++数组

    2018-03-07 21:44:23
    一维数组声明与字符数组 C++ 支持数组数据结构,它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据,但它往往被认为是一系列相同类型的变量。 数组声明并不是声明一个个单独的变量,...
  • 0716 数组

    2021-07-17 01:02:50
    数组声明与赋值 int[] arr = new int[2];...需要注意:下列写法是错误的: int[] arr; arr = {20,30,40}; 数组内存分析 栈内存:栈内存存储的都是局部变量,变量一旦出了自己的作用域,那么就
  • java 数组

    2017-08-09 22:17:09
    数组: 一维数组的创建 什么数组: 1. 数组是用来存储一组相同类型数据的数据结构。 2. 数组变量属于引用数据类型。 3. 数组是有固定长度的。 4. 数组中的元素可以是任何数据类型(基本类型和引用类型)。 5. 数组有...
  • java数组作业

    2020-04-08 23:48:12
    1. 下列数组声明的语法格式不正确的是()C A. int[] array; B. int array[]; C. char[]; D. String[] strArray; 2. 已知一个长度为10的数组b,数组b的第三个元素表示为? C A. b[3] B. b(3) C. b[2] D. b(2) 3. ...
  • Java数组练习

    2020-04-25 21:25:10
    下列数组声明的语法格式不正确的是(C) A. int[] array; B. int array[]; C. char[]; D. String[] strArray; 已知一个长度为10的数组b,数组b的第三个元素表示为? C A. b[3] B. b(3) C. b[2] D. b(2) 当数组下标...
  • //ptrs 是含有10个指针的数组 int &refs[10]; //不合法,没有引用数组 int (*Parray)[10] = &arr; // Parray 指向一个含有 10 个整数的数组 // (*Parray)[0] = arr[0]。Parray指向的是数组arr的首...
  • 数组

    2005-12-06 08:43:00
    数组毫无疑问也是众多自定义数据类型中的一种。 Type TA = array[0..9] of Integer; ... var A : TA; 和下面这段代码通常效果是相同的(不同的地方在类型篇再说) var A : Array [0..9] of Integer; 
  • 3.26数组练习

    2021-03-26 16:21:14
    1.下列数组声明的语法格式不正确的是()C A. int[] array; B. int array[]; C. char[]; D. String[] strArray; 2.已知一个长度为10的数组b,数组b的第三个元素表示为? C A. b[3] B. b(3) C. b[2] D. b(2) 3.当数组...
  • JAVA数组练习

    2020-11-23 16:16:12
    下列数组声明的语法格式不正确的是() A. int[] array; B. int array[]; C. char[]; D. String[] strArray; C 已知一个长度为10的数组b,数组b的第三个元素表示为? A. b[3] B. b(3) C. b[2] D. b(2) C 当数组下标...
  • 数组参数

    2013-05-16 15:40:01
    在C++中,数组永远不会按值传递。它是传递第一个元素(准确的说是第0个元素)的指针。例如,如下的声明:  void fun( int [10]) ; 被编译器视为: ...因此,下列三个声明是等价的:  void fun( int* ) ;
  • Java数组 练习

    2020-07-01 15:22:18
    1、下列数组声明的语法格式不正确的是(C) A. int[] array; B. int array[]; C. char[]; D. String[] strArray; 2、已知一个长度为10的数组b,数组b的第三个元素表示为? C A. b[3] B. b(3) C. b[2] D. b(2) 3、当...
  • JAVA数组作业

    2020-07-01 16:33:58
    1.下列数组声明的语法格式不正确的是()C A. int[] array; B. int array[]; C. char[]; D. String[] strArray; 2.已知一个长度为10的数组b,数组b的第三个元素表示为?C A. b[3] B. b(3) C. b[2] D. b(2) 3.当数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,751
精华内容 15,900
关键字:

下列数组声明错误的是