单选题在Java语言中，在程序运行时会自动检查数组的下标是否越界，如果越界，会抛掷下面的（）异常。A NullpointerExceptionB ArithmeticExceptioinC ArrayIndexOutOfBoundsExceptionD SecurityManager

对高级语言源程序进行编译时，可发现源程序中的(21)错误。

A．堆栈溢出

B．变量未定义

C．指针异常

D．数组元素下标越界

阅读以下程序说明和C++程序，将程序段中(1)～(5)空缺处的语句填写完整。

[说明]

C++语言本身不提供对数组下标越界的判断。为了解决这一问题，在以下[C++程序]中定义了相应的类模板，使得对于任意类型的二维数组，可以在访问数组元素的同时，对行下标和列下标进行越界判断，并给出相应的提示信息。

[C++程序]

include ＜iostream.h＞

template ＜class T＞ class Array;

template ＜Class T＞ class ArrayBody {

friend (1);

T* tpBody;

int iRows,iColumns, iCurrentRow;

ArrayBody(int IRsz, int iCsz) {

tpBody =(2);

iRows = iRsz;

iColumns = iCsz;

iCurrentRow = -1;

}

Public:

T& operator[] (int j) {

bool row_error, column_error;

row_error = column_error =false;

try {

if (iCurrentRow ＜ 0 || iCurrentRow ＞= iRows)

row_error = true;

if (j＜0 || j＞= iColumns)

column_error = true;

if (row_error == true || column_error == true)

(3);

}

catch(char){

if (row_error == true)

cerr ＜＜ "行下标越界[" ＜＜ iCurrentRow ＜＜ "]";

if (column_error = true)

cerr ＜＜ "列下标越界[" ＜＜ j ＜＜ "]";

cout ＜＜ "\n";

}

return tpBody[iCurrentRow * iColumns + j];

}

～Arraygody(){delete[]tpBody;}

};

template ＜class T＞ class Array {

ArrayBody＜T＞ tBody;

Public;

ArrayBody＜T＞ & operator[] (int i) {

(4);

return tBody;

}

Array(int iRsz, int iCsz) :(5) { }

};

void main()

{

Array＜int＞ a1(10,20);

Array＜double＞ a2(3,5);

int b1;

double b2;

b1 = a1[-5][10]; //有越界提示：行下标越界[-5]

b1 = a1[10][15]; //有越界提示：行下标越界[10]

b1 = a1[1][4]; //没有越界提示

b2 = a2[2][6]; //有越界提示：列下标越界[6]

b2 = a2[10][20]; //有越界提示：行下标越界[10]列下标越界[20]

b2 = a2[1][4]; //没有越界提示

}

以下程序执行的结果是什么？（）int[]myArray=newint[3]；try{for（inti=0；i<=myArray.length；i++）{myArray[i]=i*3；System.out.println（"myArray数组的第"+i+"个元素的值是："+myArray[i]）；}}catch（ArrayIndexOurOfBoubsExceptione）{System.out.println（"数组下标越界"）；}

A.程序执行，屏幕上显示“数组下标越界”

B.程序出现异常，屏幕上提示出现数组下标越界异常

C.程序正常执行结束，屏幕上显示数组中每个元素的值

D.程序编译出错

编译程序在语法分析阶段能检查出______错误。

A．表达式中的括号不匹配

B．以零作除数

C．数组下标越界

D．无穷递归

试题（21）

对高级语言源程序进行编译时，可发现源程序中的 （21） 错误。

（21）

A. 堆栈溢出

B. 变量未定义

C. 指针异常

D. 数组元素下标越界

阅读下列C++程序和程序说明，将应填入(n)处的字句写在对应栏内。

【说明】

C++语言本身不提供对数组下标越界的判断。为了解决这一问题，在程序6中定义了相应的类模板，使得对厂任意类型的二维数组，可以在访问数组元素的同时，对行下标和列下标进行越界判断，并给出相应的提示信息。

include＜iostream.h＞

template ＜class T＞ class Array;

template ＜class T＞ class ArrayBody {

friend (1)

T* tpBody;

int iRows, iColumns, iCurrentRow;

ArrayBody (int iRsz, int iCsz) {

tpBody =(2)

iRows = iRsz; iColumns =iCsz; iCurrentRow =-1;

}

public:

T& operator[] (int j) {

bool row_error, column_error;

row_error=column_error=false;

try{

if (iCurrentRow ＜ 0 || iCurrentRow ＞=iRows)

row_error=true;

if (j ＜ 0 || j ＞=iColumns)

column_error=true;

if ( row_error==true || column_error == true)

(3)

}

catch (char) {

if (row_error==true)

cerr ＜＜ "行下标越界[" ＜＜ iCurrentRow ＜＜ "] ";

if (column_error== true )

cerr ＜＜ "列下标越界[" ＜＜j ＜＜ "]";

cout ＜＜ "\n";

}

return tpBody[iCurrentRow * iColumns +j];

};

～ArrayBody ( ) { delete[] tpBody; }

};

template ＜class T＞ class Array {

ArrayBody＜T＞ tBody;

public:

ArrayBody＜T＞ & operator[] (int i) {

(4)

return tBody;

}

Array (int iRsz, int iCsz) :(5) {}

};

void main()

{ Array＜int＞a1(10，20)；

Array＜double＞a2(3，5)；

int b1；

double b2；

b1=a1[-5][10]； //有越界提示：行下标越界[-5]

b1=a1[10][15]； //有越界提示：行下标越界[10]

b1=a1[1][4]； //没有越界提示

b2=a2[2][6]； //有越界提示：列下标越界[6]

b2=s2[10][20]； //有越界提示：行下标越界[10]列下标越界[20]

b2=a2[1][4]； //没有越界提示

}

阅读下列说明和C++程序，将应填入(n)处的字句写在对应栏内。

【程序1说明】

程序1中定义了数组的类模板，该模板使得对于任意类型的二维数组，可以在访问数组元素的同时，对行下标和列下标进行越界判断，并给出相应的提示信息(C++语言本身不提供对下标越界的判断)。

【程序1】

include ＜ iostream. h ＞

template ＜ class T ＞ class Array2D;

template ＜ class T ＞ class Array2DBody {

friend (1);

T * tempBody;

int iRows, iColumns, iCurrentRow;

Array2DBody(int Rows,int Cols) {

tempBody =(2);

iRows = Rows;

iColumns = Cols;

iCurrentRow = -1;

}

public:

T& operator[ ] (int j){

bool row_ error, column_ error;

row_ error = column_ error = false;

try {

if ( iCurrentRow ＜ 0｜｜iCurrentRow ＞ = iRows)

row_ error = true;

if( j ＜ 0｜｜j ＞ = iColumns)

column_error = true;

if( row_error = = true [ [ column_ error = = true)

(3);

}

catch(char) {

if (row_error = = true)

cerr ＜ ＜ "行下标越界"[" ＜ ＜ iCurrentRow ＜ ＜ "]";

if( colmnn_error = = true)

cerr＜ ＜"列下标越界[" ＜ ＜j＜ ＜"]";

cout ＜ ＜ "\n";

}

return tempBody[ iCurrentRow * iColumns + j ];

}

~ Array2 DBody ( ) { delete [ ] tempBody; } }; template ＜ class T ＞ class Array2D {

Array2DBody ＜ T ＞ tBody;

public:

Array2DBody ＜ T ＞ & operalor[ ] (int i) {

tBody, iCurreutRow = i;

(4);

Array2D(int Rows,int Cols): (5) {} };

void main( )

{

Array2D ＜int＞ al ( 10,20 );

Array2D ＜double＞ a2(3,5);

int bl;

double b2;

b1=a1[-5][10]；//有越界提示：行下标越界[-5]

b1=a1[10][15]；//有越界提示：行下标越界[10]

b1=a1[1][4]；//没有越界提示

b2=a2[2][6]；//有越界提示：列下标越界[6]

b2=a2[10][20]；//有越界提示：行下标越界[10]列下标越界[20]

b2=a2[1][4]；//没有越界提示

}