下列关于C++语言数组的叙述中，错误的是
数组中所有元素的类型都相同
定义数组时必须显式给定数组各元素的初始值
定义多维数组时各维大小可以不相同
可以通过下标来访问数组的各元素
下列函数模板实现了通用的数组元素求和操作，下划线处应填入的是
#include<iostream>
using namespace std;
template <class T>
T Sum(T *ar T.intN)
{
_______
for(int i=0;i<N;i++)
m+=arr[i];
return m;
}
int main(){
int a[5]=(1,2,3,4,5);
int m=Sum(a,5);
double b[5]={1.1,2.2,3.3,4.4,5.5};
double n=Sum(b,5);
cout<<m<<','<<n<<endl;
return 0;
}
int m=0
int m
T m=0
T m
下列关于this指针的叙述中，错误的是
this指针必须显式说明
类的非静态成员函数都有this指针
类的静态成员函数没有this指针
this指针是成员函数所属对象的指针
有变量定义为"int v1,v2:"，若能以"fun(v1,&v2)"形式调用函数fun，则下列选项中，可以作为fun函数原型的是
void fun(int *x: int &y);
void fun(int &x: int &y)；
void fun(int &x: int *y);
void fun(int *x: int *y);
若有如下定义:
struct student{
int num;
int age;
}stu[3]={{1001,20},{1002,19},{1003,21}}, *p=stu;
则下列表达式中，值为19的是
P++->age
(p++)->num
(*++p).age
(*p).age
下列函数的功能是
Void fun(char *p2,char *p1)
{
while((*p2=*p1)!='\0'){
p1++;
p2++;}
}
将p1所指字符串的地址赋值给指针p2
检查p1和p2所指字符串中是否有'\0'
对p1和P2两个指针所指字符串进行比较
将p1所指字符串复制到p2所指内存空间
有如下程序:
#include <iostream>
using namespace std;
void fun(int *x,int *y){
cout<<*x<<*y;
*x=3;
*y=4;}
int main(){
int x=1;
int *y=&x;
fun(y, &x) ;
cout<<x<<*y<<endl;
return 0;}
运行后的输出结果是
3414
1144
4134
3344
若有如下定义:
struct student{
int num;
}int age; stu[3]={{1001,20},{1002,19},{1003,21}}, *p=stu;则下列表达式中，值为1002的是
(*++p).num
(*p).num
p++->num
(p++)->age
执行下列语句序列后的输出结果是
int arr[ ]={1, 2, 3, 4, 5}, *ptr=arr ;
*(ptr+2)+=2;
cout<<*ptr<<',’<<*(ptr+2);
2,4
1,5
3,5
1,3
字符串常量"MY”的长度为
1
2
3
4
若有数组定义"int a[][3] ={1,2,3,4,5,6};"，则a[1][0]的值是
1
2
4
5
若二维数组a有n列，则在a[i][j]之前的元素个数为
j*n+i
i*n+j
i*n+j-1
i*n+j+1
下列选项中，能够正确进行动态存储分配的是
int p=new int;
int p=new int (10);
int *p=new int(10);
int p[]=new int [10];
下列语句中，能够对具有5个元素的一维整型数组a进行正确初始化的是
int a[5] = (0,0,0,0,0);
int a(5) = {0,0,0,0,0};
int a[]= {0};
int a[] ={0,0,0,0,0};
下列语句中，不能对字符数组a进行正确初始化的是
char a[5]="Happy";
char a[6] = {'H', a','p', p,'y};
char a[]="Happy";
char a[] = {'H','a','p','p','y};
有如下程序:
#include<iostream>
using namespace std;
int main(){
int a[10];
for(int* p=a;p<a+10;p++)
*p=(p-a)*2+1;
cout<<a[2]+a[8]<<endl;
return 0;}运行时的输出结果是
20
21
22
23
下列关于new和delete运算符的叙述中，错误的是
delete运算符用于释放用new分配的内存空间
new运算符创建类对象时要调用构造函数
使用new创建数组时可以为数组元素指定初值
使用new和delete运算符可以动态建立或删除对象
下列关于new运算符的叙述中，错误的是
new运算符用于申请动态存储空间
new运算符返回指向申请到的动态存储空间的指针
使用new运算符创建类对象时要调用类的构造函数
使用new运算符创建数组时必须为数组元素指定初值
下列对一维数组a的定义中，语法正确的是
int a(10);
int n=7,a[n];
int n; cin>>n;int a[n];
const int size=10;int a[size];
若字符指针p所指向的字符串为“abcdefg"，在执行语句
char* ap=new char[strlen(p)+1];之后，ap指向的字符数组的元素个数为
9
8
7
6
已知函数的原型是"void f(int*x, int &y);"，变量v1、v2的定义是”intv1,v2.",下列调用语句中，正确的是
f(v1,v2);
f(v1,&v2);
f(&v1,v2);
f(&v1,&v2);
有如下语句序列:
int x=100,&r=x;
cout<<x<<'-'<<r<<endl:已知其中变量x的地址为0012FF7C，则执行该语句序列的输出结果为
100-100
100-0012FF7C
0012FF7C-100
0012FF7C-0012FF7C
要定义一个引用变量p，使用引用类MyClass的一个对象，正确的定义语句是
MyClass p=MyClass;
MyClass p=new MyClass;
MyClass &p=new MyClass;
MyClass a, &p=a;
要定义整型数组x，使之包括初值为0的三个元素，下列语句中错误的是
int x[3]={0,0,0};
int x[]={0};
static int x[3]={0};
int x[]={0,0,0};
有如下类定义:
class A{
char *a;
public:
A():a(0) {}
A(char *aa){ //把aa所指字符串拷贝到a所指向的存储空间
a=______;
strcpy(a, aa) ;
}
`A() {delete []a;}
};
横线处应填写的表达式是
new char[strlen(aa)+1]
char[strlen(aa)+1]
char[strlen(aa)]
new char[sizeof(aa)-1]
已知数组arr的定义如下:
int arr[5]={1, 2,3,4,5}下列语句中输出结果不是2的是
cout<<*arr+1<<endl;
cout<<*(arr+1)<<endl;
cout<<arr[1]<<endl;
cout<<*arr<<endl;
已知有数组定义
char a[3][4];下列表达式中错误的是
a[2]="WIN"
strcpy(a[2],"WIN")
a[2][3]='W'
a[0][1]=a[0][1]
下列语句中，正确的是
char *myString="Hello-World!"
char myString="Hello-World!"
char myString[11]="Hello-World!"
char myString[12]="Hello-World!"
有如下定义
int a[5]=(1,3,5,7,9), *p=a;下列表达式中不能得到数值5的是
a[2]
a[3]
*(p+2)
*p+4
语句int*p=&k;定义了指针p ，与这个语句等效的语句序列是
int *p;p=&k;
int *p;p=k;
int *p;*p=&k;
int*p;*p=k;
有如下程序段:
int i=0,j=l;
int &r=i; // 1
r=j; // 2
int *p=&i; // 3
*p=&r; // 4
其中会产生编译错误的语句是
4
3
2
1
有如下说明
int a[10]={1,2,3,4, 5,6,7,8, 9, 10}, *p=a;则数值为9的表达式是
*p+9
*(p+8)
*p+=9
p+8
有如下程序:
#include <iostream>
#include <iomanip >
using namespace std;
int main(){
cout.fill('*');
cout<<left<<setw(4)<<123<<"OK"<<endl;
return 0;}
执行这个程序的输出结果是
123*OK
123*OK**
*123OK
*123**OK
有如下程序
#include <iostream>
using namespace std;
int main( ){
int *p;
*p=9；
cout<<"The value at p:"<< *p;
return 0；
}
编译时出现语法错误，不能生成可执行文件
运行时一定输出:The value at P:9
运行时一定输出: The value at P:*9
运行时有可能出错
有如下程序:
#include <iostream>
void fun(int &x,int y)
{int t=x;x=y;y=t;}
int main(){
int a[2]=(23,42);
fun(a[1l, a[0]) ;
std::cout<<a[0]<<","<<a[1]<<std::endl;
return 0;}执行后的输出结果是
42,42
23,23
23,42
42, 23
要定义一个具有5个元素的一维数组vect，并使其各元素的初值依次是30，50，-88，0和0，则下列定义语句中错误的是
int vect[]={30,50,-88};
int vect[]={30,50,-88,0,0};
int vect[5]=(30,50,-88};
int vect[5]={30,50,-88,0,0};
已知n是一个int型变量，下列语句中错误的是
long *p=new long[n]
long p[n];
long *p=new long(n)
long p[10];
针对数组定义int data[10];，下列表述中错误的是
用*data可以访问到数组的首元素
用data[9]可以访问到数组的末元素
用data[10]访问数组元素会超出数组边界
data中共有10个元素，其首元素是data[1]
要定义数组A，使得其中每个元素的数据依次为:3、9、4、8、0、0、0、错误的定义语句是
int A[]= {3,9,4,8,0,0,0}
int A[7]= {3,9,4,8,0,0,0}
.int A[]={3,9,4.8}
int A[7]={3,9,4,8}
已知数组A和指针p定义为: int A[20][10],*p;，要使p指向A的首元素，正确的赋值表达式是
p=&A或 p=A[0][0]
p=A[0] 或 p=&A[0][0]
p=A或 p=&A[0][0]
p=&A[0] 或 p=A[0][0]
当类中一个字符指针成员指向具有n个字节的存储空间时，它所能存储字符串的最大长度为
n-2
n-1
n
n+1
已知:类A中一个成员函数说明如下:
void Set(A&a)
其中，A&的含义是
指向类A的指针为a
将a的地址值赋给变量Set
a是类A对象的引用，用来作函数Set()的参数
变量A与a按位与作为函数Set()的参数
在下列表示引用的方法中是正确的。已知: int m=10；
int &x=m
int &y=10
int &z
float &t=&m
对于"int*pa[5];"的描述中，————是正确的
pa是一个指向数组的指针，所指向的数组是5个int型元素
pa是一个指向某数组中第5个元素的指针，该元素是int型变量
pa [5]表示某个元素的第5个元素的值
pa是一个具有5个元素的指针数组，每个元素是一个int型指针
设"char **s;"，以下正确的表达式是
s="computer"
*s="computer"
**s="computer"
s='c'
在"int a[ ][3]={{1},{3,2},{4,5,6},{0}};"中，a[2][2]的值是
1
0
6
2
在下面的一维数组定义中_____有语法错误
int a[]={1,2,3}
int a[10]={0}
int a[]
int a[5]
下面程序的输出结果是
#include<iostream>
using namespace std；
int fun(char *);
int main(){
cout<<fun("hello") ;
return 0；}
int fun(char *s）{
char *t=s;
while(*t!=’ \0')t++;
return (t-s)；
}
语法错误
5
6
0
14、下列程序的输出结果是
#include<iostream>
using namespace std;
int n[][3]={10,20,30, 40, 50, 60} ;
int main(){
int (*p)[3];
p=n;
cout<<p[0][0]<<","<<*(p[0]+1)<<","<<(*p)[2]<<endl;
return 0;}
10 30 50
10 20 30
20 40 60
10 30 60
下列程序的功能是将数组中的所有元素全部输出，对于程序中缺少的语句，下列语句填入其中不正确的是
int a[]=(1,2,3,4);
int *pa=a;
for(int i=0;i<4;i++)
————
cout<<*a++<<' ‘
cout<<*pa++<<' ’
cout<<*(a+i)<<' ‘
cout<<*(pa+i)<<' ’
执行下面程序后，输出的结果是
#include<iostream>
using namespace std;
char *x[]=("First","Second","Third"};
void f(char *z[]){
cout<<*++z<<endl;
int main(){
char **y;
y=x;
f(y);
return 0;
}
First
Second
Third
S
设有如下程序
#include<iostream>
using namespace std;
int main(){
int **x,*y,z=10;
y=&z;
x=&y;
cout<<**x+1<<endl;
return 0;}
以上程序的输出结果是
y的地址
z的地址
11
运行错误
10、执行下列语句后，输出的结果是
#include<iostream>
using namespace std;
int main(){
int j;
int m[3][2]={10,20,30,40,50,60};
for(j=0;j<2;j++)
cout<<m[2-j][j]<<' ';
return 0;}
10 30
20 40
50 40
60 40
正确的定义一个整型数指针的语句是
int *pa;
int &pa;
int pa*;
int pa&;
定义一个整型数a的引用，正确的是
int b=&a;
int &b=&a,
int b=a;
int &b=a;
对于下列语句动态分配的内存，其释放语句正确的是
int *pa=new[10]；
delete pa[0];
delete pa;
delete *pa;
delete Ipa;
执行下列语句后，屏幕的输出结果是
#include<iostream>
using namespace std；
int main(){
int a=5；
int *pa=&a;
int &b=a;
b++;
cout<<(*pa)++<<endl;
return 0;}
5
6
7
8
关于指针，下列说法错误的是
指针中存放的实际上是内存单元的地址
指针根据其所指向变量的类型的不同，其所占用内存大小也不同
可以在指针定义的同时对其进行初始化
相同类型的指针之间可以相互赋值
将数组int a[4]=(1,2,3,4}全部输出，下列语句正确的是
cout<<a;
cout<<a[4];
for(int i=0;i<=4;i++)
cout<<a[i]；
for(int i=0;i<4;i++)
cout<<a[i];
关于动态存储分配，下列说法正确的是
new和delete是C++语言中专门用于动态内存分配和释放的函数
动态分配的内存空间也可以被初始化
当系统内存不够时，会自动回收不再使用的内存单元，因此程序中不必用delete释放内存空间
当动态分配内存失败时，系统会立刻崩溃，因此一定要慎用new
下列程序的输出结果是
#include<iostream>
using namespace std;
int main()
{char a[]="Hello, World”；
char *ptr=a;
while(*ptr){
if(*ptr>='a'&&*ptr<='z')
cout<<char(*ptr+'A'-'a')；
else cout<<*ptr;
ptr++;}
return 0;}
HELLO,WORLD
Hello,World
hELLO,WORLD
hello,world
己知: int m=10;在下列定义引用的语句中，正确的是
int &x=m;
int y=&m;
int &z;
int &t=&m;